Basic Interview Questions
are the three main differences between flexgrid control and dbgrid(Data bound
The Microsoft FlexGrid (MSFlexGrid) control displays and operates on tabular
data. It allows complete flexibility to sort, merge, and format tables
containing strings and pictures. When bound to a Data control, MSFlexGrid
displays read-only data.Adaptation to existing Visual Basic code for the
data-bound grid (DBGrid).
dbgrid is A spreadsheet-like bound control that displays a series of rows and
columns representing records and fields from a Recordset object.
The data grids are bound controls; that is, they require a data source that
actually connects to a database and retrieves their data. And it seems that the
root of the problem with DBGrid is that there's no data source that can be
readily included along with the DBGrid control.
In Visual Basic, the solution is simply to include the Data Control on the same
form as DBGrid. But the Data Control is an intrinsic control; it's unavailable
to anything outside of the Visual Basic environment itself. and VB 6.0 has a new
set of data controls (DataGrid, DataList, DataCombo, MSHFlexGrid, MSFlexGrid)
that once again are bound controls. Unlike DBGrid, though, they support OLE DB,
and therefore rely on the an ADO Data Source (and in particular the ActiveX Data
Objects Data Control, or ADO DC) for data access. Unlike the Data Control, the
DC is a custom control (that is, an .OCX) that can be added to any project. In
short, if you add ADO DC to your project along with the DataGrid control.
ActiveX and Types of ActiveX Components in VB ?
What is difference between inprocess and out of process ?
An in-process component is implemented as a DLL, and runs in the same process
space as its client app, enabling the most efficient communication between
client and component.Each client app that uses the component starts a new
instance of it.
An out of process component is implemented as an EXE, and unlike a dll, runs in
its own process space. As a result, exe's are slower then dll's
because communications between client and component must be marshalled across
process boundaries. A single instance of an out of process component can service
Advantage of ActiveX Dll over Active Exe ?
An in-process component, or ActiveX DLL, runs in another application?s
process. In-process components are used by applications or other in-process
components. this allows you to wrap up common functionality (like an ActiveX
An out-of-process component, or ActiveX EXE, runs in its own address space. The
client is usually an application running in another process.The code running in
an ActiveX Exe is running in a separate process space. You would usually use
this in N-Tier programming.
An ActiveX EXE runs out of process while an ActiveX DLL runs in the same process
space as VB app. Also, and ActiveX EXE can be run independent of your
application if desired.
Explain single thread and multithread thread apartments?
All components created with Visual Basic use the apartment model, whether
they?re single-threaded or multithreaded. A single-threaded component has only
one apartment, which contains all the objects the component provides.
This means that a single-threaded DLL created with Visual Basic is safe to use
with a multithreaded client. However, there?s a performance trade-off for this
safety. Calls from all client threads except one are marshaled, just as if they
were out-of-process calls.
What is a Component?
If you compile an ActiveX dll, it becomes a component.
If you compile an ActiveX Control, it becomes both a component and a control.
Component is a general term used to describe code that's grouped by
functionality. More specifically, a component in COM terms is a compiled
collection of properties/methods and events.
Typically a component is loaded into your project via the References whereas an
ActiveX Control is loaded into your project via "components".
What is meant by "Early Binding" and "Late Binding"?
Which is better?
Early binding and late binding refer to the method used to bind an interface's
properties and methods to an object reference (variable). Early binding uses
type library information at design time to reference procedures, while late
binding handles this at run time. Late binding
handles this by interrogating the reference before each call to insure that it
supports a particular method. Since every call to a late bound
object actually requires two calls.