Cad iad bainisteorí comhthéacs agus an ráiteas with?

Question

Accepted Answer

Is éard atá i **bainisteoir comhthéacs** ná réad a shainmhíníonn loighic socraithe agus stopadh, úsáidte leis an **`with`** ráiteas. Baistíonn sé gur tharlaíonn glanadh (comhaid a dhúnadh, glasanna a scaoileadh, idirghabhálacha a bhogadh siar) go huathoibríoch — fiú má thugann earráid faoi.

## An fhadhb a réitíonn sé

```python
# ❌ manual cleanup — error-prone; if processing throws, the file never closes
f = open("file.txt")
data = f.read()
process(data)        # if this raises, f.close() below is skipped → leaked file handle
f.close()

# ✅ with statement — guarantees the file is closed, no matter what
with open("file.txt") as f:
    data = f.read()
    process(data)
# f is automatically closed here — even if process() raised an exception
```

Tuigeannn an bloc `with` go rithear `f.close()` nuair a scoir an bloc, ar bhealach gnáth nó trí imeagla — ag foluain acmhainní leachta ó ghlanadh dearmadta nó scaipthe.

## Bainisteorí comhthéacs coitianta

```python
with open("f.txt") as f: ...           # files (auto-close)
with lock:                              # threading locks (auto-release)
    shared_resource += 1
with db.transaction():                  # DB transactions (auto-commit/rollback)
    ...
with open("a") as a, open("b") as b:    # multiple at once
    ...
```

## A scríobh do do chuid féin — an bealach ranga

```python
class Timer:
    def __enter__(self):                 # SETUP — runs at `with` entry
        self.start = time.perf_counter()
        return self                       # the value bound to `as`
    def __exit__(self, exc_type, exc_val, tb):  # TEARDOWN — runs at exit (even on error)
        print(f"took {time.perf_counter() - self.start:.3f}s")
        # return False → propagate any exception; True → suppress it

with Timer():
    do_work()
```

Cuireann bainisteoir comhthéacs `__enter__` (socrú) agus `__exit__` (glanadh, a fhaigheann aon fhaisnéis imeagla) i bhfeidhm.

## An bealach níos éasca — contextlib

```python
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    try:
        yield                            # everything before yield = setup; after = teardown
    finally:
        print(f"took {time.perf_counter() - start:.3f}s")

with timer():
    do_work()
```

Tarraingíonn an `@contextmanager` athrúchán gineadóir ina bhainisteoir comhthéacs — socrú roimh `yield`, glanadh ina dhiaidh (in `finally` ar mhaithe le sábháilteacht).

## Cén fáth a bhfuil sé tábhachtach

Is é an bealach Pythonic a chur i bhfeidhm ar **bhainistiú acmhainní slán** iad bainisteorí comhthéacs agus `with` — ag gealladh go ndúnfar comhaid, go scaoilfear glasanna, go ndéanfar ceangail a thabhairt ar ais, agus go críochnófar idirghabhálacha, fiú nuair a thugann eisceachtaí faoi.

Leigheasann sé seo leachta acmhainní agus stát neamhchomhsheasmhach, foinse choitianta fabhtanna le glanadh láimhe.

Úsáidtear go tóir iad (ba cheart go n-úsáidfí `with` ar gach oibríocht chomhaid), agus a bheith ar an eolas conas a scríobh do do chuid féin (trí `__enter__`/`__exit__` nó an `@contextmanager` níos simplí) ligint duit aon phatrún socraithe/stopadh a dhúnmhúchadh go geal agus go iontaofa.