Typescript Disposable (using statement)

Using.ts

// NOTE: This is now rolled up in a package and supports more scenarios: https://github.com/dsherret/using-statement

interface IDisposable {
    dispose();
}

function using<T extends IDisposable>(resource: T, func: (resource: T) => void) {
    try {
        func(resource);
    } finally {
        resource.dispose();
    }
}

// Example use:

class Camera implements IDisposable {
    takePicture() { /* omitted */ }
    // etc...
    dispose() {
        navigator.camera.cleanup();
    }
}

using(new Camera(), (camera) => {
    camera.takePicture();
});

very well done

Just came here via a google search - any chance this is in the typescript future spec?

Here is a modification i made to it, so it works with async/await

/**
 * Provides a mechanism for releasing resources.
 */
export interface IDisposable {
    dispose(): Promise<void>;
}

/**
 * Provides a convenient syntax that ensures the correct use of IDisposable objects
 */
export async function using<T extends IDisposable>(resource: T, func: (resource: T) => Promise<void>) {
    try {
        await func(resource);
    } finally {
        await resource.dispose();
    }
}

// example

(async () => {
    await using(ioc.get<IUdpClient>(types.IUdpClient), async (client) => {
        client.connect(endpoint);
        client.send({toBuffer: () => Buffer.from("hello world1")});
        let response = await client.receive();
        console.log(response);

        await Task.delay(1000);
        client.send({toBuffer: () => Buffer.from("hello world2")});
        response = await client.receive();
        console.log(response);


        console.log("using complete");
    });
    console.log("end");
})();

Really nice!

Very very nice, good and elegant solutions.

Awesome idea. @nite take a look at this beauty https://github.com/tc39/proposal-using-statement

Very cool. Have you considered turning this into an NPM module? I agree that it should be a language construct.

@fitfinderaustralia done and it supports more scenarios such as async and generator functions: https://github.com/dsherret/using-statement

Great work - I love it!

Great!

Appreciated 👏.

Nice

@maca134 in case you want to return a value from it

export async function using<T extends IDisposable, U>(resource: T, func: (resource: T) => Promise<U>) {
    try {
        return await func(resource);
    } finally {
        await resource.dispose();
    }
}