Jaki jest Managed C++ równoważne do C# using

Question

jaki sposób jeden kod następujący kod C# w Managed C++

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

Clarificaton: Dla zarządzanych obiektów.

Answer 1

Zakładając znaczy C++/CLI (nie stary Managed C++), są następujące opcje:

(1) naśladować używając-Block z wykorzystaniem automatycznych/stackbased obiektów:

{ 
    SqlConnection conn(connectionString); 
} 

Spowoduje to wywołanie Destruktora obiektu "conn", gdy kończy się następny zamykający blok. Niezależnie od tego, czy jest to funkcja obejmująca, czy też blok dodawany ręcznie do limitu zasięgu, nie ma znaczenia.

(2) Wyraźnie nazywamy „wyrzucić”, to znaczy zniszczeniu obiektu

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

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

Pierwszy z nich jest zamiennikiem „za”. Drugi to opcja, zazwyczaj nie musisz tego robić, chyba że opcjonalnie przekażesz odniesienie gdzie indziej.

Answer 2

Jeżeli obawiasz się o ograniczenie żywotności zmienna, a nie automatycznego usuwania, zawsze można po prostu umieścić go w swoim zakresie:

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

Answer 3

Aby do tego w Managed C++ po prostu użyć semantyki stos.

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

Po wykryciu znaku krzyżyka wywoływana jest funkcja "Destruktor", tj. Usuwanie().

Answer 4

Można zrobić coś podobny w stylu auto_ptr:

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

z następujących czynności:

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) 

Dla porównania:

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

Answer 5

#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 

}