'using' scope in C# and sharpdx -

the question more c# related, started learining sharpdx , came on 2 ways initialize resources. first stores resource (texture2d in example) global variable. in code assigns value , passes sharpdx's method (and down c++ sharpdx encapsulates)

backbufferptr = m_swapchain.getbackbuffer<texture2d>(0) _rendertargetview = new rendertargetview(m_device, backbufferptr); 

and calls dispose on it, in dispose method of class calls it, keeping texture2d entire lifetime of class.

the other uses using statement:

using(texture2d backbuffer = _swapchain.getbackbuffer<texture2d>(0)) {     _rendertargetview = new rendertargetview(_d3d11device, backbuffer); } 

and wonder why 2nd works. checked in debugger , long stop inside using statement both

backbuffer.nativepointer _rendertargetview.resource.nativepointer 

point @ same object in memmory. leave using statement backbuffer disposed , no longer points @ anything, _rendertargetview.resource doesn't change, , still points @ object did in using statement.

i did quick test:

class innerclass {     public texture2d someresource; } /****/ innerclass ic = new innerclass();  using (texture2d t2 = m_swapchain.getbackbuffer<texture2d>(0)) {      ic.someresource = t2; } 

here both t2 , ic.someresource disposed, , point @ nothing, leave using block, how expected work in first place.

now, questions are:

1) should assume that, in first example, it's sharpdx's method makes sure inner resuorce doesn't disposed, though c# object, got passed it, did? , won't crash @ point if c# decides overwrite memory block?

2) what's better/safer way of passing such resources? using block, or declare @ beginning , dispose @ end?

sharpdx keeps count of references underlying graphics resources. example, when acquire reference buffer:

texture2d backbuffer = _swapchain.getbackbuffer<texture2d>(0)

and obtain render target view same underlying resources:

_rendertargetview = new rendertargetview(_d3d11device, backbuffer);

you need dispose both of them swap chain release buffer resources gpu.

---

what's better/safer way of passing such resources? using block, or declare @ beginning , dispose @ end?

i quess depends on usage, i've seen, class acquires handle resource dispose of in own implementation of idisposable.