C# 6.0 완벽 가이드/ 스트림과 입출력

using System; using System.IO; class Program { static void Main() { using (Stream s = new FileStream("test.txt", FileMode.Create)) { Console.WriteLine(s.CanRead); // true Console.WriteLine(s.CanWrite); // true Console.WriteLine(s.CanSeek); // true s.WriteByte(101); s.WriteByte(102); byte[] block = { 1, 2, 3, 4, 5, }; s.Write(block, 0, block.Length); // 5바이트 블록을 기록한다. Console.WriteLine(s.Length); // 7 Console.WriteLine(s.Position); // 7 s.Position = 0; // 시작 위치로 돌아간다. Console.WriteLine(s.ReadByte()); // 101 Console.WriteLine(s.ReadByte()); // 102 // 스트림을 읽어서 block 배열을 다시 채운다. Console.WriteLine(s.Read(block, 0, block.Length)); // 5 // 위의 Read 호출이 5를 돌려주어다고 가정하면 현재 위치느느 파일의 끝이므로 다음 Read는 0을 돌려준다. Console.WriteLine(s.Read(block, 0, block.Length)); // 0 } } }

async static void AsyncDemo() { using (Stream s = new FileStream("test.txt", FileMode.Create)) { byte[] block = { 1, 2, 3, 4, 5, }; await s.WriteAsync(block, 0, block.Length); // 비동기 쓰기 s.Position = 0; // 시작 위치로 돌아간다.2 // 스트림을 읽어서 block 배열을 다시 채운다. Console.WriteLine(await s.ReadAsync(block, 0, block.Length)); // 5 } }

// s가 스트림이라고 가정 byte[] data = new byte[1000]; s.Read(data, 0, data.Length);

byte[] data = new byte[1000]; // 스트림의 크기가 1000 미만이라고 해도 결국에는 bytesRead가 1000에 도달한다. int bytesRead = 0; int chunkSize = 1; while(bytesRead < data.Length && chunkSize > 0) bytesRead += chunkSize = s.Read(data, bytesRead, data.Length - bytesRead);

byte[] data = new BinaryReader(s).ReadBytes(1000);

s.Flush(); s.Close();

FileStream fs1 = File.OpenRead("readme.bin"); // 읽기 전용 FileStream fs2 = File.OpenWrite(@"c:\temp\writeme.tmp"); // 쓰기 전용 FileStream fs3 = File.OpenCreate(@"c\temp\writeme.tmp"); // 읽기/쓰기

var fs = new FileStream("readwrite.tmp", FileMode.Open); // 읽기/쓰기

int longLines = File.ReadLines("파일 경로").Count(l => l.Length > 80);

string baseFolder = AppDomain.CurrentDomain.BaseDirectory; string logoPath = Path.Combine(baseFolder, "logo.jpg");

if (File.Exists("hidden.txt")) File.Delete("hidden.txt");

[Flags] public enum FileAccess { Read = 1, Write = 2, ReadWrite = 3 }

using (var fs = new FileStream("x.bin", FileMode.Open, FileAccess.Read)) ...

using (var fs = new FileStream("x.bin", FileMode.Open, FileAccess.Read)) { fs.Seek(0, SeekOrigin.End); ... }

// 이들은 FileStream 클래스에 정의되어 있다. public virtual void Lock(long position, long length); public virtual void Unlock(long position, long length);

var ms = new MemoryStream(); sourceStream.CopyTo(ms);

using (var s = new NamedPipeServerStream("pipedream")) { s.WaitForConnection(); s.WriteByte(100); Console.WriteLine(s.ReadByte()); }

using (var s = new NamedPipeClientStream("pipedream")) { s.Connect(); Console.WriteLine(s.ReadByte()); s.WriteByte(200); // 200이라는 값을 돌려보낸다. }

static byte[] ReadMessage(PipeStream s) { MemoryStream ms = new MemoryStream(); byte[] buffer = new byte[0x1000]; // 4kb 블록 단위로 읽어 들인다. do { ms.Write(buffer, 0, s.Read(buffer, 0, buffer.Length)); } while (!s.IsMessageComplete); return ms.ToArray(); }

using (var s = new NamedPipeServerStream("pipedream", PipeDirection.InOut, 1, PipeTransmissionMode.Message)) { s.WaitForConnection(); byte[] msg = Encoding.UTF8.GetBytes("Hello"); s.WriteByte(msg, 0, msg.Length); Console.WriteLine(Encoding.UTF8.GetString(ReadMessage(s))); }

using (var s = new NamedPipeClientStream("pipedream")) { s.Connect(); s.ReadMode = PipeTransmissionMode.Message; Console.WriteLine(Encoding.UTF8.GetString(s))); byte[] msg = Encoding.UTF8.GetBytes("Hello right back!"); s.Write(msg, 0, msg.Length); }

string clientExe = @"d:\PipeDemo\ClientDemo.exe"; HandleInheritability inherit = HandleInheritability.Inheritable; using (var tx = new AnonymousPipeServerStream (PipeDirection.Out, inherit)) using (var rx = new AnonymoutPipeServerStream (PipeDirection.In, inherit)) { string txID = tx.GetClientHandleAsString(); string rxID = rx.GetClientHandleAsString(); var startInfo = new ProcessStartInfo(clientExe, txID + " " + rxID); startInfo.UseShellExcute = false; // 자식 프로세스에 필요한 설정 Process p = Process.Start(startInfo); tx.DisposeLocalCopyOfClientHandle(); // 비관리 핸들 자원들을 해제한다. rx.DisposeLocalCopyOfClientHandle(); tx.WriteByte(100); Console.WriteLine("Server received: " + rx.ReadByte()); p.WaitForExit(); }

string rxID = args[0]; string txID = args[1]; using (var rx = new AnonymousPipeClientStream (PipeDirection.In, rxID)) using (var tx = new AnonymousPipeClientStream (PipeDirection.Out, txID)) { Console.WriteLine("Client received: " + rx.ReadByte()); tx.WriteByte(200); }

// 파일에 100KB의 자료를 기록한다. File.WriteAllBytes("myFile.bin", new byte[100000]); using (FileStream fs = File.OpenRead("myFile.bin")) using (BufferedStream bs = new BufferedStream(fs, 20000)) // 20kb의 버퍼 { bs.ReadByte(); Console.WriteLine(fs.Position); // 20000 }

using (FileStream fs = File.Create("text.txt")) using (TextWriter writer = new StreamWriter(fs)) { writer.WriteLine("Line1"); writer.WriteLine("Line2"); } using (FileStream fs = File.OpenRead("text.txt")) using (TextReader reader = new StreamReader(fs)) { Console.WriteLine(reader.ReadLine()); // Line1; Console.WriteLine(reader.ReadLine()); // Line2; }

using (TextWriter writer = File.CreateText("test.txt")) { writer.WriteLine("Line1"); writer.WriteLine("Line2"); } using (TextWriter writer = File.AppendText("test.txt")) { writer.WriteLine("Line3"); } using (TextReader reader = File.OpenText("test.txt")) { while (reader.Peek() > -1) Console.WriteLine(reader.ReadLine()); }

using (TextWriter writer = File.CreateText("data.txt")) { writer.WriteLine(123); // "123"을 기록한다. writer.WriteLine(true); // 단어 "True"를 기록한다. } using (TextReader reader = File.OpenText("data.txt")) { int myInt = int.Parse(r.ReadLine()); bool yes = bool.Parse(r.ReadLine()); }

var encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier:false, throwOnInvalidBytes:true);

using (TextWriter writer = File.CreateText("but.txt")) // 기본 UTF-8 부호화를 사용한다. { writer.WriteLine("but-"); } using (TextReader reader = File.OpenText("but.txt")) { for (int b; (b = s.ReadByte()) > -1;) Console.WriteLine(b); }

98 // b 117 // u 116 // t 226 // 엠 대시 바이트 1 - 이런 다중 바이트열의 모든 바이트가 128보다 큰 값임을 주목할 것 128 // 엠 대시 바이트 2 148 // 엠 대시 바이트 3 13 // <CR> 10 // <LF>

using (Stream s = File.Create("but.txt")) using (TextWriter writer = new StreamWriter(s, Encoding.Unicode)) writer.WriteLine("but-"); foreach(byte b in File.ReadAllBytes("but.txt")) Console.WriteLine(b);

255 // 바이트 순서 표시(BOM) 1 254 // 바이트 순서 표시 2 98 // b 바이트 1 0 // b 바이트 2 117 // u 바이트 1 0 // u 바이트 2 116 // t 바이트 1 0 // t 바이트 2 20 // - 바이트 1 32 // - 바이트 2 13 // <CR> 바이트 1 0 // <CR> 바이트 2 10 // <LF> 바이트 1 0 // <LF> 바이트 2

XmlReader r = XmlReader.Create(new StringReader(myString));

public class Person { public string Name; public int Age; public double Height; }

public void SaveData(Stream s) { var w = new BinaryWriter (s); w.Write(Name); w.Write(Age); w.Write(Height); w.Flush(); // BinaryWriter의 버퍼를 확실히 비운다. BinaryWriter 자체가 닫히거나 처분되지는 않으므로 계속해서 스트림에 자료를 쓸 수 있다. } public void LoadData(Stream s) { var r = new BinaryReader(s); Name = r.ReadString(); Age = r.ReadInt32(); Height = r.ReadDouble(); }

byte[] data = new BinaryReader(s).ReadBYtes((int)s.Length);

using (FileStream fs = File.Create("test.txt")) using (TextWriter writer = new StreamWriter(fs)) writer.WriteLine("Line");

using (FileStream fs = new FileStream("test.txt", FileMode.Create)) { StreamWriter writer = new StreamWriter(fs); writer.WriteLine("Hello"); writer.Flush(); fs.Position = 0; Console.WriteLine(fs.ReadByte()); }

using (FileStream fs = new FileStream("test.txt", FileMode.Create)) { using (StreamWriter writer = new StreamWriter(fs, new UTF8Encoding(false, true), 0x400, true); writer.WriteLine("Hello"); fs.Position = 0; Console.WriteLine(fs.ReadByte()); Console.WriteLIne(fs.Length); }

using (Stream s = File.Create("compressed.bin")) using (Stream ds = new DeflateStream(s, CompressionMode.Compress)) { for (byte i = 0; i < 100; i++) ds.WriteByte(i); } using (Stream s = File.OpenRead("compressed.bin")) using (Stream ds = new DeflateStream(s, CompressionMode.Decompress)) for (byte i = 0; i < 100; i++) Console.WriteLine(ds.ReadByte());

byte[] data = new byte[1000]; var ms = new MemoryStream(); using (Stream ds = new DeflateStream(ms, CompressionMode.Compress)) ds.Write(data, 0, data.Length); byte[] compressed = ms.ToArray(); Console.WriteLine(compressed.Length); // 11 // 압축을 해제해서 다시 data 배열에 넣는다. ms = new MemoryStream(compressed); using (Stream ds = new DeflateStream(ms, CompressionMode.Decompress)) for (int i = 0; i < 1000; i += ds.Read(data, i, 1000-i));

byte[] data = new byte[1000]; var ms = new MemoryStream(); using (Stream ds = new DeflateStream(ms, CompressionMode.Compress, true)) await ds.WriteAsync(data, 0, data.Length); Console.WriteLine(ms.Length); // 113 ms.Position - 0; using (Stream ds = new DeflateStream(ms, CompressionMode.Decompress)) for (int i = 0; i < 1000; i += ds.ReadAsync(data, i, 1000-i));

ZipFile.CreateFromDirectory(@"d:\MyFolder", @"d:\compressed.zip");

ZipFile.ExtractToDirectory(@"d:\compressed.zip", @"d:\MyFolder");

using (ZipArchive zip = ZipFile.Open(@"d:\zz.zip", ZipArchiveMode.Read)) foreach (ZipArchiveEntry entry in zip.Entries) Console.WriteLine(entry.FullName + " " + entry.Length);

byte[] data = File.ReadAllBytes(@"d:\foo.dll"); using (ZipArchive zip = ZipFile.Open(@"d:\zz.zip", ZipArchiveMode.Update)) zip.CreateEntry(@"bin\X64\foo.dll).Open().Write(data, 0, data.Length);

string filePath = @"c:\temp\test.txt"; FileAttributes fa = File.GetAttributes(filePath); if ((fa & FileAttributes.ReadOnly) != 0) { fa ^= FileAttributes.ReadOnly; File.SetAttributes(filePath, fa); } // 이제 파일이 읽기 전용이 아니므로 삭제할 수 있다. File.Delete(filePath);

new FileInfo(@"c:\temp\test.txt").IsReadOnly = false;

static uint CompressFolder (string folder, bool recursive) { string path = "Win32_Directory.Name='" + folder +"'"; using (ManagementObject dir = new ManagementObject(path)) using (ManagementBaseObject p = dir.GetMethodParameters("CompressEx")) { p["Recursive"] = recursive; using (ManagementBaseObject result = dir.InvokeMethod("CompressEx", p, null)) return (uint) result.Properties["ReturnValue"].Value; } }

using System; using System.IO; using System.Text; using System.ComponentModel; using System.Runtime.InteropServices; class SupportsCompressionEncryption { const int SupportsCompression = 0x10; const int SupportsEncryption = 0x20000; [DllImport("Kernel32.dll", SetLastError = true)] extern static bool GetVolumeInformation (string vol, StringBuilder name, int nameSize, out uint serialNum, out uint maxNameLen, out uint flags, StringBuilder fileSysName, int fileSysNameSize); static void Main() { uint serialNum, maxNameLen, flags; bool ok = GetVolumnInformation(@"C:\", null, 0, out serialNum, out maxNameLen, out flags, null, 0); if (!ok) throw new Win32Exception(); bool canCompress = (flags & SupportsCompression) != 0; bool canEncryp = (flags & SupportsEncryption) != 0; } }

using System; using System.IO; using System.Security.AccessControl; using System.Security.Principal; ... FileSecurity sec = File.GetAccessControl(@"d:\test.txt"); AuthorizationRuleCollection rules = sec.GetAccessRules(true, true, typeof(NTAccount)); foreach (FileSystemAccessRule rule in rules) { Console.WriteLine(rule.AccessControlType); // Allow 또는 Deny Console.WriteLine(rule.FileSystemRights); // 이를테면 FullControl Console.WriteLine(rule.IdentityReference.Value); // 이를테면 MyDoamin/Joe } var sid = new SecurityIdentifier (WellKnownSidtype.BuiltinUsersSid, null); string usersAccount = sid.Translate(typeof(NTAccount)).ToString(); FIleSystemAccessRule newRule = new FileSystemAccessRule(usersAccount, FileSystemRights.ExecuteFile, AccessControlType.Allow); sec.AddAccessRule(newRule); File.SetAccessControl(@"d:\test\txt", sec);

DirectoryInfo di = new DirectoryInfo(@"e\photos"); foreach(FileInfo fi in di.GetFiles("*.jpg")) Console.WriteLine(fi.Name); foreach(DirectoryInfo subDir in di.GetDirectories()) Console.WriteLine(subDir.FullName);

string dir = @"c:\mydir"; string file = "myfile.txt"; string path = @"c:\mydir\myfile.txt"; Directory.SetCurrentDirectory(@"k:\demo");

string myDocPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()

string localAppDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Application), "MyCoolApplication"); if (!Directory.Exists(localAppDataPath)) Directory.CreateDirectory(localAppDataPath);

public void AssignUseresFullControlToFolder(string path) { try { var sec = Directory.GetAccessControl(path); if (UsersHaveFullControl (esc)) return; var rule = new FileSystemAccessRule( GetUsersAccount().ToString(), FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | IneritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow); sec.AddAccessRule(rule); Directory.SetAccessControl(path, sec); } catch (UnauthorizedAccessException) { // 해당 폴더를 다른 사용자가 이미 생성햇음 } } bool UsersHaveFullControl(FileSystemSecurity sec) { var usersAccount = GetUsersAccount(); var rules = sec.GetAccessRules(true, true, typeof(NTAccount)).OfType<FileSystemAccessRule>(); return rules.Any(r => r.FileSystemRights == FileSystemRights.FullControl && r.AccessControlType == AccessControltype.Allow && r.InheritanceFlags == (InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit) && r.IdentityReference == usersAccount); } NtAccount GetUsersAccount() { var sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null); return (NTAccount)sid.Translate(typeof(NTAccount)); }

DriveInfo c = new DriveInfo("C"); // C: 드라이브를 질의한다. long totalSize = c.TotalSize; // 크기 (바이트 단위) long freeBytes = c.TotalFreeSpace; // 디스크 할당량(쿼터)은 무시한 가용 용량 long freeToMe = c.AvailableFreeSpace; // 디스크 할당량도 포함한 가용 용량 foreach (DriveInfo d in DriveInfo.GetDrives()) // 정의된 모든 드라이브를 나열 { Console.WriteLine(d.Name); // C:\ Console.WriteLine(d.DriveType); // Fixed Console.WriteLine(d.RootDirectory); // C:\ if (d.IsReady) // 드라이브라 준비되지 않은 상태이면 다음 속성들이 예외를 던진다. { Console.WriteLine(d.VolumeLabel); // The Sea Drive Console.WriteLine(d.DriveFormat); // NTFS } }

Unknown, NoRootDirectory, Removable, Fixed, Network, CDRom, Ram

static void Main() { Watch(@"c:\temp", "*.txt", true); } static void Watch(string path, string filter, bool includeSubDirs) { using (var watcher = new FileSYstemWatcher(path, filter)) { watcher.Created += FileCreatedChangedDeleted; watcher.Changed += FileCreatedChangedDeleted; watcher.Deleted += FileCreatedChangedDeleted; watcher.Renamed += FileRenamed; watcher.Error += FileError; watcher.IncludeSubdirectories = includeSubDirs; watcher.EnableRaisingEvents = true; Console.WriteLine("이벤트 청취 중 - 종료하려면 Enter 키를 누르세요"); Console.ReadLine(); } // FileSystemWatcher를 처분하면 이벤트가 더 이상 발동되지 않는다. } static void FileCreatedChangedDeleted(object o, FileSystemEventArgs e) => Console.WriteLine("파일 {0}, {1}", e.FullPath, e.ChangeType); static void FileRenamed(object o, RenamedEventArgs e) => Console.WriteLine("이름 바뀜: {0} -> {1}", e.OldFullPath, e.FullPath); static void FileError(object o, ErrorEventArgs e) => Console.WriteLine("오류: " + e.GetException().Message);

File.WriteAllBytes("long.bin", new byte[1000000]); using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile("long.bin")) using (MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor()) { accessor.Write(500000, (byte)77); Console.WriteLine(accessor.ReadByte(5000000); // 77 }

using (MemoryMappedFile mmf = MemoryMappedFile.CreateFromFile("long.bin"), FileMode.Create, null, 1000)) ...

using (MemoryMappedFile mmf = MemoryMappedFile.CreateNew("Demo", 500)) using (MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor()) { accessor.Write(0, 12345); Console.ReadLine(); // 사용자가 엔터키를 누를 때까지 공유 메모리를 살려 둔다. }

// 다음을 개별적인 실행 파일(exe)에서 실행할 수도 있다. using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting("Demo")) using (MemoryMappedViewAccessor accessor = mmf.CreateViewAccessor()) { Console.WriteLine(accessor.ReadInt32(0)); // 12345 }

byte[] data = Encoding.UTF8.GetBytes("시험용 텍스트"); accessor.Write(0, data.Length); accessor.WriteArray(4, data, 0, data.Length);

byte[] data = new byte[accessor.ReadInt32(0)] accessor.ReadArray(4, data, 0, data.Length); Console.WriteLine(Encoding.UTF8.GetString(data)); // 시험용 텍스트

struct Data { public int X, Y; } ... var data = new Data { X = 123, Y = 456 }; accessor.Write(0, ref data); accessor.Read(0, out data); Console.WriteLine(data.X + " " + data.Y); // 123 456

unsafe { byte* pointer = null; try { accessor.SafeMomoryMappedViewHandle.AcquirePointer(ref pointer); int* intPointer = (int*) pointer; Console.WriteLine(*intPointer); // 123 } finally { if (pointer != null) accessor.SafeMemoryMappedViewHandle.ReleasePointer(); } }