Typescript: using 문으로 리소스 관리

// csharp-using/text.txt
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla consectetur enim lorem, vestibulum egestas nibh consectetur quis. Nam a fringilla est, eu fringilla dui. Vestibulum neque quam, dignissim ut blandit in, suscipit laoreet dolor. Cras hendrerit urna at elit pellentesque, in bibendum libero laoreet. Nam interdum sapien id metus scelerisque facilisis. Praesent venenatis viverra lacus, nec varius mi mattis at. Sed malesuada velit risus, et pharetra arcu rhoncus sed. Duis sit amet tincidunt nisl, vel gravida ante.

Morbi egestas eu nisl et bibendum. Duis placerat sodales nulla, sed dictum libero mattis vel. Suspendisse velit sapien, scelerisque vel massa quis, ultrices vestibulum mauris. Vestibulum sit amet viverra leo, quis euismod sem. Aliquam dignissim arcu nec lectus lacinia, at pretium urna aliquam. Interdum et malesuada fames ac ante ipsum primis in faucibus. Duis lectus nunc, hendrerit eget lobortis nec, rutrum ut risus. Morbi porta orci velit, et viverra magna ullamcorper ac. Praesent commodo, turpis ut facilisis scelerisque, felis enim efficitur risus, et elementum sapien arcu vel tellus. Praesent feugiat aliquet consequat. Mauris in leo suscipit, molestie erat ut, cursus nibh. In luctus dui et nulla luctus, a elementum libero aliquet. Mauris finibus bibendum vestibulum. Quisque rhoncus purus at turpis hendrerit accumsan. Praesent posuere sapien dolor, vel feugiat sem fermentum vel. Donec massa dui, pulvinar eget quam a, aliquet malesuada arcu.

Curabitur non lorem ut justo luctus luctus. Vivamus ac congue nunc, ac tincidunt velit. Praesent nulla nisl, sollicitudin sed venenatis id, pharetra id neque. Donec tellus magna, dignissim nec faucibus vel, facilisis quis ligula. Nullam eget aliquam nisi. Mauris imperdiet nunc sed augue iaculis euismod. Duis sollicitudin posuere mauris eget accumsan. Etiam vestibulum est at sagittis maximus. Pellentesque mollis diam quis purus venenatis, vel cursus risus dictum. Vivamus elementum, magna ac eleifend rutrum, velit tellus mollis odio, sed volutpat quam felis quis tellus. Morbi a feugiat metus. Nullam sodales sem eu ligula pulvinar, a pellentesque tellus vehicula. Curabitur nec mi ornare, laoreet mi eu, molestie arcu. Curabitur ex lacus, ultricies a dui nec, placerat finibus enim. Vestibulum euismod a dolor eu vulputate.

Donec ac malesuada nisl, ut tincidunt neque. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Aenean rhoncus eros non maximus fringilla. Curabitur lobortis ac lacus in aliquam. Morbi id arcu dui. Cras quis erat cursus, aliquam dolor et, vestibulum risus. Sed eleifend hendrerit nulla, sed maximus risus pellentesque at. Phasellus a placerat metus, vel maximus justo. Sed semper gravida risus, vel pulvinar diam pharetra at. Sed pellentesque libero mi, vitae semper ligula porta in. Suspendisse ornare, arcu nec euismod suscipit, lectus sem placerat nulla, id eleifend nisl mauris et purus. Duis in eros a nibh venenatis posuere.

Morbi rhoncus orci tortor. Vivamus cursus dolor in magna efficitur, a iaculis ligula imperdiet. Curabitur nec consectetur lectus, non bibendum quam. Nullam mollis posuere auctor. Quisque scelerisque luctus ante, vel auctor justo finibus quis. Aenean efficitur massa non nisi blandit, nec ullamcorper lectus egestas. In sed sodales dolor, sed accumsan mi. Nunc tincidunt porttitor arcu in semper. Phasellus rhoncus felis elementum justo tempor, sed congue turpis condimentum. Nam aliquet felis in pharetra convallis. Ut vestibulum hendrerit odio, et aliquet massa fringilla vitae. Fusce est risus, varius nec turpis sit amet, varius consectetur elit. Nam tristique nulla nisl, sed venenatis nunc pretium a.

// csharp-using/main.cs
using System.IO;

var buffer = new char[50];
using (var reader = new StreamReader("text.txt"))
{
  int charsRead = 0;
  while (reader.Peek() != -1)
  {
    charsRead = reader.Read(buffer, 0, buffer.Length);
    Console.Write(buffer, 0, charsRead);
  }
}

> dotnet tool install -g dotnet-script
...
You can invoke the tool using the following command: dotnet-script
Tool 'dotnet-script' (version '1.6.0') was successfully installed.

> dotnet script main.cs
...Nam tristique nulla nisl, sed venenatis nunc pretium a.

finally
{
    streamReader?.Dispose();
}

// typescript-using/append-file.ts
import fs from "fs";

function appendToFile(filePath: string, content: string): void {
  let fd: number | null = null;

  try {
    // Open file for appending
    fd = fs.openSync(filePath, "a");

    const buffer = Buffer.from(content, "utf8");
    fs.writeSync(fd, buffer);

    console.log(`텍스트 추가 성공 ${filePath}`);
  } catch (error) {
    console.error("텍스트 추가 실패:", error);
  } finally {
    if (fd !== null) {
      fs.closeSync(fd);
    }
  }
}

appendToFile("test.txt", "Hello, world!");
appendToFile("test.txt", "Hello, World!");

// typescript-using/using-append-file.ts
import fs from "fs";

class FileDescriptor implements Disposable {
  private fd: number;

  constructor(filePath: string, mode: string) {
    this.fd = fs.openSync(filePath, mode);
  }

  get descriptor(): number {
    return this.fd;
  }

  /**
   * 파일 디스크립터가 선언된 스코프를 벗어날 때, 자동으로 파일 디스크립터를 해제합니다.
   */
  [Symbol.dispose](): void {
    if (this.fd !== null) {
      fs.closeSync(this.fd);
      console.log("File descriptor closed automatically");
    }
  }
}

function appendToFileWithUsing(filePath: string, content: string): void {
  try {
      // using 카워드로 선언된 객체는 선언된 스코프를 벗어날 때 자동으로 Symbol.dispose를 호출합니다.
      using file = new FileDescriptor(filePath, "a");

      const buffer = Buffer.from(content, "utf8");
      fs.writeSync(file.descriptor, buffer);

    console.log(`Successfully appended to ${filePath}`);
  } catch (error) {
    console.error("Error appending to file:", error);
    // 에러가 발생하더라도 파일 디스크립터는 자동으로 해제됩니다!
  }
}

appendToFileWithUsing("test.txt", "Hello, world!");
appendToFileWithUsing("test.txt", "Hello, World!");

> npx ts-node ./using-append-file.ts
Successfully appended to test.txt
File descriptor closed automatically
Successfully appended to test.txt
File descriptor closed automatically

function appendToFileWithUsing(filePath, content) {
  try {
    const env_1 = { stack: [], error: void 0, hasError: false };
    try {
      // using 카워드로 선언된 객체는 선언된 스코프를 벗어날 때 자동으로 Symbol.dispose를 호출합니다.
      const file = __addDisposableResource(
        env_1,
        new FileDescriptor(filePath, "a"),
        false
      );
      const buffer = Buffer.from(content, "utf8");
      fs_1.default.writeSync(file.descriptor, buffer);
      console.log(`Successfully appended to ${filePath}`);
    } catch (e_1) {
      env_1.error = e_1;
      env_1.hasError = true;
    } finally {
      __disposeResources(env_1);
    }
  } catch (error) {
    console.error("Error appending to file:", error);
    // 에러가 발생하더라도 파일 디스크립터는 자동으로 해제됩니다!
  }
}

function syncLoggy(id: string): Disposable {
  console.log(`Creating ${id}`);
  return {
      [Symbol.dispose]() {
          console.log(`Disposing ${id}`);
      }
  }
}

function syncFunc() {
  using a = syncLoggy("a");
  using b = syncLoggy("b");
  {
      using c = syncLoggy("c");
      using d = syncLoggy("d");
  }
  using e = syncLoggy("e");
  return;
  // return 문 이후의 코드는 실행되지 않습니다.
  using f = syncLoggy("f");
}

syncFunc();

> npx ts-node ./dispose-order.ts
Creating a
Creating b
Creating c
Creating d
Disposing d
Disposing c
Creating e
Disposing e
Disposing b
Disposing a

async function doWork() {
  // 0.5초 동안 대기합니다.
  await new Promise(resolve => setTimeout(resolve, 500));
}

function asyncLoggy(id: string): AsyncDisposable {
  console.log(`Constructing ${id}`);
  return {
      async [Symbol.asyncDispose]() {
          console.log(`Disposing (async) ${id}`);
          await doWork();
      },
  }
}

async function asyncFunc() {
  await using a = asyncLoggy("a");
  await using b = asyncLoggy("b");
  {
      await using c = asyncLoggy("c");
      await using d = asyncLoggy("d");
  }
  await using e = asyncLoggy("e");
  return;
}
asyncFunc();

> npx ts-node ./async-dispose.ts
Constructing a
Constructing b
Constructing c
Constructing d
Disposing (async) d
Disposing (async) c
Constructing e
Disposing (async) e
Disposing (async) b
Disposing (async) a

// typescript-using/disposableTimer.ts
import { DisposableStack } from "@whatwg-node/disposablestack"

async function disposableTimerFunc() {
  using disposer = new DisposableStack();
  // disposer.use(disposableTimer(() => console.log("timer tick"), 1000));
  const timer = setInterval(() => console.log("timer tick"), 1000);
  disposer.defer(() => {
    clearInterval(timer);
    console.log("timer disposed");
  });

  console.log("5초 동안 타이머를 기다립니다...");
  await new Promise(resolve => setTimeout(resolve, 5000));
}

disposableTimerFunc();

> npx ts-node ./disposableTimer.ts
5초 동안 타이머를 기다립니다...
timer tick
timer tick
timer tick
timer tick
timer disposed