Qual é o Managed C ++ equivalente ao C # usando instrução

Question

Como é que um código o seguinte código C # no Managed C ++

void Foo()
{
    using (SqlConnection con = new SqlConnection("connectionStringGoesHere"))
    {
         //do stuff
    }
}

Clarificaton: Para objetos gerenciados.

Answer 1

Assumindo que você média C ++ / CLI (não o velho Managed C ++), o seguinte são as opções:

(1) Mimic um usando-Block com o uso de objetos automáticas / stackbased:

{
  SqlConnection conn(connectionString);
}

Isso irá chamar o Destructor do "conn" objeto quando o bloco termina ao lado de fechamento. Se esta é a função de inclusão, ou um bloco de adicionar manualmente o escopo limite não importa.

(2) Explicitamente chamar "Eliminar", ou seja, destruir o objeto:

SqlConnection^ conn = nullptr;
try
{
  conn = gcnew SqlConnection(conntectionString);

}
finally
{
  if (conn != nullptr)
    delete conn;
}

O primeiro seria o substituto direto para "usando". A segunda é uma opção, normalmente você não vai precisar fazer a menos que você opcionalmente passar a referência para algum outro lugar.

Answer 2

Para a isso em C ++ gerenciado só usar semântica de pilha.

void Foo(){
   SqlConnection con("connectionStringGoesHere");
    //do stuff
}

Ao con sai do escopo do "Destructor", ou seja, Dispose (), é chamado.

Answer 3

Você poderia fazer algo semelhante em estilo auto_ptr:

void foo()
{
    using( Foo, p, gcnew Foo() )
    {
        p->x = 100;
    }
}

com o seguinte:

template <typename T>
public ref class using_auto_ptr
{
public:
    using_auto_ptr(T ^p) : m_p(p),m_use(1) {}
    ~using_auto_ptr() { delete m_p; }
    T^ operator -> () { return m_p; }
    int m_use;
private:
    T ^ m_p;
};

#define using(CLASS,VAR,ALLOC) \
    for ( using_auto_ptr<CLASS> VAR(ALLOC); VAR.m_use; --VAR.m_use)

Para referência:

public ref class Foo
{
public:
    Foo() : x(0) {}
    ~Foo()
    {
    }
    int x;
};

Answer 4

#include <iostream>

using namespace std;


class Disposable{
private:
    int disposed=0;
public:
    int notDisposed(){
        return !disposed;
    }

    void doDispose(){
        disposed = true;
        dispose();
    }

    virtual void dispose(){}

};



class Connection : public Disposable {

private:
    Connection *previous=nullptr;
public:
    static Connection *instance;

    Connection(){
        previous=instance;
        instance=this;
    }

    void dispose(){
        delete instance;
        instance = previous;
    }
};

Connection *Connection::instance=nullptr;


#define using(obj) for(Disposable *__tmpPtr=obj;__tmpPtr->notDisposed();__tmpPtr->doDispose())

int Execute(const char* query){
    if(Connection::instance == nullptr){
        cout << "------- No Connection -------" << endl;
        cout << query << endl;
        cout << "------------------------------" << endl;
        cout << endl;

        return -1;//throw some Exception
    }

    cout << "------ Execution Result ------" << endl;
    cout << query << endl;
    cout << "------------------------------" << endl;
    cout << endl;

    return 0;
}

int main(int argc, const char * argv[]) {

    using(new Connection())
    {
        Execute("SELECT King FROM goats");//out of the scope
    }

    Execute("SELECT * FROM goats");//in the scope

}

Answer 5

Se você estiver preocupado sobre como limitar a vida útil da variável em vez de eliminação automática, você pode sempre colocá-lo em seu próprio escopo:

void Foo()
{
    {
        SqlConnection con = new SqlConnection("connectionStringGoesHere");
        // do stuff
        // delete it before end of scope of course!
    }
}