임베디드 리소스 텍스트 파일을 읽는 방법

사용하여 포함 된 리소스 (텍스트 파일)를 읽고 StreamReader문자열로 반환하려면 어떻게합니까? 현재 스크립트는 Windows 양식과 텍스트 상자를 사용하여 사용자가 포함되지 않은 텍스트 파일에서 텍스트를 찾아서 바꿀 수 있도록합니다.

private void button1_Click(object sender, EventArgs e)
{
    StringCollection strValuesToSearch = new StringCollection();
    strValuesToSearch.Add("Apple");
    string stringToReplace;
    stringToReplace = textBox1.Text;

    StreamReader FileReader = new StreamReader(@"C:\MyFile.txt");
    string FileContents;
    FileContents = FileReader.ReadToEnd();
    FileReader.Close();
    foreach (string s in strValuesToSearch)
    {
        if (FileContents.Contains(s))
            FileContents = FileContents.Replace(s, stringToReplace);
    }
    StreamWriter FileWriter = new StreamWriter(@"MyFile.txt");
    FileWriter.Write(FileContents);
    FileWriter.Close();
}

당신은 Assembly.GetManifestResourceStream방법을 사용할 수 있습니다 :

1. 다음 용도를 추가하십시오

   using System.IO;
   using System.Reflection;
   

2. 관련 파일의 속성 설정 : 값이있는
   매개 변수Build ActionEmbedded Resource

3. 다음 코드를 사용하십시오

   var assembly = Assembly.GetExecutingAssembly();
   var resourceName = "MyCompany.MyProduct.MyFile.txt";
   
   using (Stream stream = assembly.GetManifestResourceStream(resourceName))
   using (StreamReader reader = new StreamReader(stream))
   {
       string result = reader.ReadToEnd();
   }
   

   resourceName에 포함 된 리소스 중 하나의 이름입니다 assembly. 라는 이름의 텍스트 파일을 포함 할 경우 예를 들어, "MyFile.txt"기본 네임 스페이스 프로젝트의 루트에 위치 "MyCompany.MyProduct"하고 resourceName있습니다 "MyCompany.MyProduct.MyFile.txt". Assembly.GetManifestResourceNamesMethod를 사용하여 어셈블리의 모든 리소스 목록을 얻을 수 있습니다 .

resourceName파일 이름에서만 (이름 공간 항목을 전달하여) 가져 오기를 꺼려하는 사람은 없습니다 .

string resourceName = assembly.GetManifestResourceNames()
  .Single(str => str.EndsWith("YourFileName.txt"));

완전한 예 :

public string ReadResource(string name)
{
    // Determine path
    var assembly = Assembly.GetExecutingAssembly();
    string resourcePath = name;
    // Format: "{Namespace}.{Folder}.{filename}.{Extension}"
    if (!name.StartsWith(nameof(SignificantDrawerCompiler)))
    {
        resourcePath = assembly.GetManifestResourceNames()
            .Single(str => str.EndsWith(name));
    }

    using (Stream stream = assembly.GetManifestResourceStream(resourcePath))
    using (StreamReader reader = new StreamReader(stream))
    {
        return reader.ReadToEnd();
    }
}

두 가지 방법으로 파일을 리소스로 추가 할 수 있습니다.

파일에 액세스하는 데 필요한 C # 코드 는 처음에 파일을 추가하는 데 사용 된 방법에 따라 다릅니다.

방법 1 : 기존 파일 추가, 속성 설정 Embedded Resource

파일을 프로젝트에 추가 한 다음 유형을로 설정하십시오 Embedded Resource.

참고 :이 방법을 사용하여 파일을 추가하면 파일 GetManifestResourceStream에 액세스 할 수 있습니다 ( @dtb의 답변 참조 ).

방법 2 : 파일 추가 Resources.resx

Resources.resx파일을 열고 드롭 다운 상자를 사용 하여 파일을 추가하고로 설정 Access Modifier하십시오 public.

참고 :이 방법을 사용하여 파일을 추가하면 파일 Properties.Resources에 액세스 할 수 있습니다 ( @Night Walker의 답변 참조 ).

기본적으로 System.Reflection현재 어셈블리에 대한 참조를 얻는 데 사용 합니다. 그런 다음을 사용 GetManifestResourceStream()합니다.

예를 들어, 내가 게시 한 페이지에서 :

참고 : 추가해야 할 using System.Reflection;일이 위해를

   Assembly _assembly;
   StreamReader _textStreamReader;

   try
   {
      _assembly = Assembly.GetExecutingAssembly();
      _textStreamReader = new StreamReader(_assembly.GetManifestResourceStream("MyNamespace.MyTextFile.txt"));
   }
   catch
   {
      MessageBox.Show("Error accessing resources!");
   }

Visual Studio에서는 프로젝트 속성 (이 예에서는 "분석")의 리소스 탭을 통해 파일 리소스에 직접 액세스 할 수 있습니다.

그런 다음 결과 파일에 의해 바이트 배열로 액세스 할 수 있습니다

byte[] jsonSecrets = GoogleAnalyticsExtractor.Properties.Resources.client_secrets_reporter;

스트림으로 필요하면 ( https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

파일을 리소스에 추가 할 때 다음과 같이 만들 수있는 것보다 Access 수정자를 공개로 선택해야합니다.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01은 포함 된 파일의 이름입니다.

실제로 resources.Designer.cs로 이동하여 getter의 이름이 무엇인지 확인할 수 있습니다.

Testfile.sql 프로젝트 메뉴 추가-> 속성-> 리소스-> 기존 파일 추가

    string queryFromResourceFile = Properties.Resources.Testfile.ToString();

나는 그것이 오래된 실이라는 것을 알고 있지만 이것이 나를 위해 일한 것입니다.

1. 텍스트 파일을 프로젝트 리소스에 추가
2. Andrew Hill이 위에서 설명한 것처럼 액세스 수정자를 공개로 설정하십시오.

3. 다음과 같은 텍스트를 읽으십시오.

   textBox1 = new TextBox();
   textBox1.Text = Properties.Resources.SomeText;

리소스에 추가 한 텍스트 : 'SomeText.txt'

이 단순화 된 버전의 @dtb의 답변을 사용할 수도 있습니다.

public string GetEmbeddedResource(string ns, string res)
{
    using (var reader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("{0}.{1}", ns, res))))
    {
        return reader.ReadToEnd();
    }
}

내가 지금 배운 것은 파일에 "."을 사용할 수 없다는 것입니다. 파일 이름에서 (점).

Templates.plainEmailBodyTemplate-en.txt-> 작동 !!!
Templates.plainEmailBodyTemplate.en.txt->는 GetManifestResourceStream ()을 통해 작동하지 않습니다

아마도 프레임 워크가 네임 스페이스와 파일 이름을 혼동하기 때문에 ...

모든 힘을 합쳐서이 도우미 클래스를 사용하여 모든 어셈블리와 네임 스페이스에서 일반적인 방식으로 리소스를 읽습니다.

public class ResourceReader
{
    public static IEnumerable<string> FindEmbededResources<TAssembly>(Func<string, bool> predicate)
    {
        if (predicate == null) throw new ArgumentNullException(nameof(predicate));

        return
            GetEmbededResourceNames<TAssembly>()
                .Where(predicate)
                .Select(name => ReadEmbededResource(typeof(TAssembly), name))
                .Where(x => !string.IsNullOrEmpty(x));
    }

    public static IEnumerable<string> GetEmbededResourceNames<TAssembly>()
    {
        var assembly = Assembly.GetAssembly(typeof(TAssembly));
        return assembly.GetManifestResourceNames();
    }

    public static string ReadEmbededResource<TAssembly, TNamespace>(string name)
    {
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));
        return ReadEmbededResource(typeof(TAssembly), typeof(TNamespace), name);
    }

    public static string ReadEmbededResource(Type assemblyType, Type namespaceType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (namespaceType == null) throw new ArgumentNullException(nameof(namespaceType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        return ReadEmbededResource(assemblyType, $"{namespaceType.Namespace}.{name}");
    }

    public static string ReadEmbededResource(Type assemblyType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        var assembly = Assembly.GetAssembly(assemblyType);
        using (var resourceStream = assembly.GetManifestResourceStream(name))
        {
            if (resourceStream == null) return null;
            using (var streamReader = new StreamReader(resourceStream))
            {
                return streamReader.ReadToEnd();
            }
        }
    }
}

임베디드 리소스 텍스트 파일 사용을 읽었습니다.

    /// <summary>
    /// Converts to generic list a byte array
    /// </summary>
    /// <param name="content">byte array (embedded resource)</param>
    /// <returns>generic list of strings</returns>
    private List<string> GetLines(byte[] content)
    {
        string s = Encoding.Default.GetString(content, 0, content.Length - 1);
        return new List<string>(s.Split(new[] { Environment.NewLine }, StringSplitOptions.None));
    }

견본:

var template = GetLines(Properties.Resources.LasTemplate /* resource name */);

template.ForEach(ln =>
{
    Debug.WriteLine(ln);
});

나는 이것이 오래 되었다는 것을 알고 있지만 NETMF (.Net MicroFramework) 를 지적하고 싶었습니다. 쉽게 수행 할 수 있습니다.

string response = Resources.GetString(Resources.StringResources.MyFileName);

이후 NETMF는 없습니다GetManifestResourceStream

여기에 게시 된 모든 솔루션을 읽은 후. 이것이 내가 해결 한 방법입니다.

// How to embedded a "Text file" inside of a C# project
//   and read it as a resource from c# code:
//
// (1) Add Text File to Project.  example: 'myfile.txt'
//
// (2) Change Text File Properties:
//      Build-action: EmbeddedResource
//      Logical-name: myfile.txt      
//          (note only 1 dot permitted in filename)
//
// (3) from c# get the string for the entire embedded file as follows:
//
//     string myfile = GetEmbeddedResourceFile("myfile.txt");

public static string GetEmbeddedResourceFile(string filename) {
    var a = System.Reflection.Assembly.GetExecutingAssembly();
    using (var s = a.GetManifestResourceStream(filename))
    using (var r = new System.IO.StreamReader(s))
    {
        string result = r.ReadToEnd();
        return result;
    }
    return "";      
}

resources.resx에서 직접 파일을 추가 한 경우 간단하게 대답 할 수 있습니다.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

해당 코드 줄을 사용하면 파일의 텍스트를 파일에서 직접 읽고 문자열 변수에 넣습니다.

네임 스페이스와 폴더를 항상 문자열에 포함시켜야한다는 것이 짜증났습니다. 임베디드 리소스에 대한 액세스를 단순화하고 싶었습니다. 이것이 제가이 작은 수업을 쓴 이유입니다. 자유롭게 사용하고 개선하십시오!

용법:

using(Stream stream = EmbeddedResources.ExecutingResources.GetStream("filename.txt"))
{
 //...
}

수업:

public class EmbeddedResources
{
    private static readonly Lazy<EmbeddedResources> _callingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetCallingAssembly()));

    private static readonly Lazy<EmbeddedResources> _entryResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetEntryAssembly()));

    private static readonly Lazy<EmbeddedResources> _executingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetExecutingAssembly()));

    private readonly Assembly _assembly;

    private readonly string[] _resources;

    public EmbeddedResources(Assembly assembly)
    {
        _assembly = assembly;
        _resources = assembly.GetManifestResourceNames();
    }

    public static EmbeddedResources CallingResources => _callingResources.Value;

    public static EmbeddedResources EntryResources => _entryResources.Value;

    public static EmbeddedResources ExecutingResources => _executingResources.Value;

    public Stream GetStream(string resName) => _assembly.GetManifestResourceStream(_resources.Single(s => s.Contains(resName)));

}

일부 VS .NET 프로젝트 유형은 .NET (.resx) 파일을 자동 생성하지 않습니다. 다음 단계는 프로젝트에 리소스 파일을 추가합니다.

1. 프로젝트 노드를 마우스 오른쪽 단추로 클릭하고 추가 / 새 항목 추가를 선택하고 자원 파일로 화면 이동하십시오. 이름 상자에서 리소스와 같은 적절한 이름을 선택하고 추가 버튼을 클릭하십시오.
2. 리소스 파일 Resources.resx가 프로젝트에 추가되며 솔루션 탐색기에서 노드로 볼 수 있습니다.
3. 실제로 두 개의 파일이 작성되며 자동 생성 된 C # 클래스 Resources.Designer.cs도 있습니다. 편집하지 마십시오. VS에서 유지 관리합니다. 이 파일에는이라는 클래스가 포함되어 있습니다 Resources.

이제 텍스트 파일을 리소스로 추가 할 수 있습니다 (예 : xml 파일).

1. Resources.resx를 두 번 클릭하십시오. 자원 추가> 기존 파일 추가를 선택하고 포함 할 파일로 화면 이동하십시오. 액세스 수정의 기본값은 내부로 두십시오.
2. 아이콘은 새로운 자원 항목을 나타냅니다. 선택하면 속성 창에 속성이 표시됩니다. xml 파일의 경우 인코딩 특성 아래에서 기본 로컬 코드 페이지 대신 유니 코드 (UTF-8) – 코드 페이지 65001을 선택하십시오. 다른 텍스트 파일의 경우이 파일의 올바른 인코딩 (예 : 코드 페이지 1252)을 선택하십시오.
3. xml 파일과 같은 텍스트 파일의 경우 클래스 Resources에는 string포함 된 파일의 이름을 딴 유형의 속성이 있습니다. 파일 이름이 예를 들어 RibbonManifest.xml 인 경우 속성의 이름은이어야합니다 RibbonManifest. 코드 파일 Resources.Designer.cs에서 정확한 이름을 찾을 수 있습니다.
4. 다른 문자열 속성과 같이 문자열 속성을 사용하십시오 (예 :) string xml = Resources.RibbonManifest. 일반적인 형태는 ResourceFileName.IncludedTextFileName입니다. ResourceManager.GetString문자열 속성의 get-function이 이미 수행 했으므로 사용하지 마십시오 .

public class AssemblyTextFileReader
{
    private readonly Assembly _assembly;

    public AssemblyTextFileReader(Assembly assembly)
    {
        _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
    }

    public async Task<string> ReadFileAsync(string fileName)
    {
        var resourceName = _assembly.GetManifestResourceName(fileName);

        using (var stream = _assembly.GetManifestResourceStream(resourceName))
        {
            using (var reader = new StreamReader(stream))
            {
                return await reader.ReadToEndAsync();
            }
        }
    }
}

public static class AssemblyExtensions
{
    public static string GetManifestResourceName(this Assembly assembly, string fileName)
    {
        string name = assembly.GetManifestResourceNames().SingleOrDefault(n => n.EndsWith(fileName, StringComparison.InvariantCultureIgnoreCase));

        if (string.IsNullOrEmpty(name))
        {
            throw new FileNotFoundException($"Embedded file '{fileName}' could not be found in assembly '{assembly.FullName}'.", fileName);
        }

        return name;
    }
}

이것은 현재의 임베디드 리소스 파일을 읽는 데 매우 편리한 클래스입니다 Assembly.

using System.IO;
using System.Linq;
using System.Text;
using static System.IO.Path;
using static System.Reflection.Assembly;

public static class EmbeddedResourceUtils
{
    public static string ReadFromResourceFile(string endingFileName)
    {
        var assembly = GetExecutingAssembly();
        var manifestResourceNames = assembly.GetManifestResourceNames();

        foreach (var resourceName in manifestResourceNames)
        {
            var fileNameFromResourceName = _GetFileNameFromResourceName(resourceName);
            if (!fileNameFromResourceName.EndsWith(endingFileName))
            {
                continue;
            }

            using (var manifestResourceStream = assembly.GetManifestResourceStream(resourceName))
            {
                if (manifestResourceStream == null)
                {
                    continue;
                }

                using (var streamReader = new StreamReader(manifestResourceStream))
                {
                    return streamReader.ReadToEnd();
                }
            }
        }

        return null;
    }

    // https://stackoverflow.com/a/32176198/3764804
    private static string _GetFileNameFromResourceName(string resourceName)
    {
        var stringBuilder = new StringBuilder();
        var escapeDot = false;
        var haveExtension = false;

        for (var resourceNameIndex = resourceName.Length - 1;
            resourceNameIndex >= 0;
            resourceNameIndex--)
        {
            if (resourceName[resourceNameIndex] == '_')
            {
                escapeDot = true;
                continue;
            }

            if (resourceName[resourceNameIndex] == '.')
            {
                if (!escapeDot)
                {
                    if (haveExtension)
                    {
                        stringBuilder.Append('\\');
                        continue;
                    }

                    haveExtension = true;
                }
            }
            else
            {
                escapeDot = false;
            }

            stringBuilder.Append(resourceName[resourceNameIndex]);
        }

        var fileName = GetDirectoryName(stringBuilder.ToString());
        return fileName == null ? null : new string(fileName.Reverse().ToArray());
    }
}

winforms에서 하드 코드 된 파일의 텍스트를 빠르게 원하는 모든 사람들에게;

1. 솔루션 탐색기> 자원> 파일 추가에서 애플리케이션을 마우스 오른쪽 단추로 클릭하십시오.
2. 그것을 클릭하고 속성 탭에서 "FileType"을 "Text"로 설정하십시오.
3. 프로그램 Resources.<name of resource>.toString();에서 파일을 읽으십시오.

나는 이것을 모범 사례 또는 다른 것으로 권장하지 않지만 신속하게 작동하고 필요한 작업을 수행합니다.

VB.Net을 사용하는 사용자의 경우

Imports System.IO
Imports System.Reflection

Dim reader As StreamReader
Dim ass As Assembly = Assembly.GetExecutingAssembly()
Dim sFileName = "MyApplicationName.JavaScript.js" 
Dim reader = New StreamReader(ass.GetManifestResourceStream(sFileName))
Dim sScriptText = reader.ReadToEnd()
reader.Close()

어디 MyApplicationName내 응용 프로그램의 네임 스페이스는 ? 어셈블리 이름이 아닙니다. 이 이름은 프로젝트 속성 (응용 프로그램 탭)에서 정의됩니다.

올바른 리소스 이름을 찾지 못하면 GetManifestResourceNames()기능을 사용할 수 있습니다

Dim resourceName() As String = ass.GetManifestResourceNames()

또는

Dim sName As String 
    = ass.GetManifestResourceNames()
        .Single(Function(x) x.EndsWith("JavaScript.js"))

또는

Dim sNameList 
    = ass.GetManifestResourceNames()
        .Where(Function(x As String) x.EndsWith(".js"))

양식로드 이벤트에서 내장 TXT 파일을 읽습니다.

변수를 동적으로 설정하십시오.

string f1 = "AppName.File1.Ext";
string f2 = "AppName.File2.Ext";
string f3 = "AppName.File3.Ext";

시험해보십시오.

try 
{
     IncludeText(f1,f2,f3); 
     /// Pass the Resources Dynamically 
     /// through the call stack.
}

catch (Exception Ex)
{
     MessageBox.Show(Ex.Message);  
     /// Error for if the Stream is Null.
}

IncludeText ()에 대한 Void 만들기, Visual Studio가이를 수행합니다. 전구를 클릭하여 CodeBlock을 자동 생성하십시오.

생성 된 코드 블록 안에 다음을 넣습니다.

리소스 1

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file1))
using (StreamReader reader = new StreamReader(stream))
{
string result1 = reader.ReadToEnd();
richTextBox1.AppendText(result1 + Environment.NewLine + Environment.NewLine );
}

리소스 2

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file2))
using (StreamReader reader = new StreamReader(stream))
{
string result2 = reader.ReadToEnd();
richTextBox1.AppendText(
result2 + Environment.NewLine + 
Environment.NewLine );
}

자원 3

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file3))

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    richTextBox1.AppendText(result3);
}

다른 곳에서 반환 된 변수를 보내려면 다른 함수를 호출하고 ...

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    ///richTextBox1.AppendText(result3);
    string extVar = result3;

    /// another try catch here.

   try {

   SendVariableToLocation(extVar)
   {
         //// Put Code Here.
   }

       }

  catch (Exception ex)
  {
    Messagebox.Show(ex.Message);
  }

}

이것이 달성 한 것은 하나의 서식있는 텍스트 상자 안에서 여러 txt 파일을 결합하고 포함 된 데이터를 읽는 방법입니다. 이 코드 샘플에서 원하는 효과였습니다.