Это невозможно в Entity Framework. Вы либо включаете всю таблицу (с Include
, как вы это делаете), либо вообще не включаете ее. Если вы хотите загрузить только определенные столбцы, вы можете сделать это, но посмотрите, как это ручной процесс:
Context
.Select(i => new YourType
{
c = i.l,
l = i.l,
x = new X
{
a = i.x.a // only the properties you want here
}
...
});
В тот момент, когда вы используете Select
, Include
полностью игнорируется, поэтому вы не можете используйте оба.
Деструктор A будет работать, когда закончится его время жизни. Если вы хотите освободить память и запустить деструктор, вы должны удалить ее, если она была выделена в куче. Если он был выделен в стеке, это происходит автоматически (т. Е. Когда оно выходит за пределы области видимости, см. Раздел RAII). Если это член класса (не указатель, а полный член), то это произойдет, когда содержащийся объект будет уничтожен.
class A
{
char *someHeapMemory;
public:
A() : someHeapMemory(new char[1000]) {}
~A() { delete[] someHeapMemory; }
};
class B
{
A* APtr;
public:
B() : APtr(new A()) {}
~B() { delete APtr; }
};
class C
{
A Amember;
public:
C() : Amember() {}
~C() {} // A is freed / destructed automatically.
};
int main()
{
B* BPtr = new B();
delete BPtr; // Calls ~B() which calls ~A()
C *CPtr = new C();
delete CPtr;
B b;
C c;
} // b and c are freed/destructed automatically
В приведенном выше примере каждое удаление и удаление [ ] необходим. И никакое удаление не требуется (или действительно может быть использовано), где я его не использовал.
auto_ptr
, unique_ptr
и shared_ptr
и т. Д. ... отлично подходят для такого управления жизненным циклом проще:
class A
{
shared_array<char> someHeapMemory;
public:
A() : someHeapMemory(new char[1000]) {}
~A() { } // someHeapMemory is delete[]d automatically
};
class B
{
shared_ptr<A> APtr;
public:
B() : APtr(new A()) {}
~B() { } // APtr is deleted automatically
};
int main()
{
shared_ptr<B> BPtr = new B();
} // BPtr is deleted automatically
class B
{
public:
B()
{
p = new int[1024];
}
virtual ~B()
{
cout<<"B destructor"<<endl;
//p will not be deleted EVER unless you do it manually.
}
int *p;
};
class D : public B
{
public:
virtual ~D()
{
cout<<"D destructor"<<endl;
}
};
Когда вы выполните:
B *pD = new D();
delete pD;
Деструктор будет вызываться, только если ваш базовый класс имеет ключевое слово virtual.
Тогда, если у вас не было виртуального деструктора, вызывается только ~ B (). Но поскольку у вас есть виртуальный деструктор, вызывается первая ~ D (), а затем ~ B ().
Никакие члены B или D, выделенные в куче, не будут освобождены, если вы их явно не удалите. И удаление их также вызовет их деструктор.
Вы должны удалить A самостоятельно в деструкторе B.
no, он не будет вызывать деструктор для класса A, вы должны явно называть его (например, PoweRoy), удалить строку 'delete ptr;' в примере для сравнения ...
#include <iostream>
class A
{
public:
A(){};
~A();
};
A::~A()
{
std::cout << "Destructor of A" << std::endl;
}
class B
{
public:
B(){ptr = new A();};
~B();
private:
A* ptr;
};
B::~B()
{
delete ptr;
std::cout << "Destructor of B" << std::endl;
}
int main()
{
B* b = new B();
delete b;
return 0;
}
У вас есть что-то вроде
class B
{
A * a;
}
B * b = new B;
b->a = new A;
. Если вы затем вызываете delete b;
, ничего не происходит с a, и у вас есть утечка памяти. Попытка запомнить delete b->a;
не является хорошим решением, но есть пара других.
B::~B() {delete a;}
Это деструктор для B, который удалит a. (Если a равно 0, это удаление ничего не делает. Если a не является 0, но не указывает на память от нового, вы получаете повреждение кучи.)
auto_ptr<A> a;
...
b->a.reset(new A);
Таким образом, у вас нет как указатель, а скорее auto_ptr & lt;> (shared_ptr & lt;> будет делать также или другие интеллектуальные указатели), и он автоматически удаляется, когда b.
Любой из этих способов работает хорошо, и я Вы использовали оба.
Мне было интересно, почему мой деструктор класса не был вызван. Причина в том, что я забыл включить определение этого класса (#include "class.h"). У меня было только объявление типа «класс А»; и компилятор был доволен этим, и позвольте мне называть «delete».
Деструктор для объекта класса A будет вызываться только при вызове delete для этого объекта. Обязательно удалите этот указатель в деструкторе класса B.
Для получения дополнительной информации о том, что происходит при вызове delete на объект, см.: http://www.parashift.com /c++-faq-lite/freestore-mgmt.html#faq-16.9
Нет. указатель будет удален. Вы должны называть delete в A явным в деструкторе B.
Он называется «деструктор», а не «deconstructor».
Внутри деструктора каждого класса вам нужно удалить все остальные переменные-члены, которые были назначены новым.
edit: Чтобы уточнить:
Скажите, что у вас есть
struct A {}
class B {
A *a;
public:
B () : a (new A) {}
~B() { delete a; }
};
class C {
A *a;
public:
C () : a (new A) {}
};
int main () {
delete new B;
delete new C;
}
Выделение экземпляра B, а затем удаление является чистым, потому что то, что B выделяет внутри, также будет удалено в деструкторе.
Но экземпляры класса C будут утечки памяти, поскольку он выделяет экземпляр A, который он не выпускает (в этом случае C даже не имеет деструктора).
Если у вас есть обычный указатель (A*
), деструктор не будет вызван (и память для экземпляра A
не будет освобождена), если вы не сделаете delete
явно в деструкторе B
. Если вы хотите автоматическое уничтожение, посмотрите на интеллектуальные указатели, такие как auto_ptr
.
Когда вы вызываете delete на указателе, выделенном new, вызывается деструктор объекта, на который указывает.
A * p = new A;
delete p; // A:~A() called for you on obkect pointed to by p