I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth to a
class module?
For example, say I have a data access module that creates a large
disconnected dataset from a database. I want to pass that dataset back to
the calling program. And then perhaps I want to send that dataset to another
class module.
At first it seems that the "object oriented" approach would be to create a
dataset property in each class module, then run a method that creates the
dataset, and then read the property from the calling program. (and visa
versa if I want to send a dataset to another class module).
Now admittedly, I am not sure I understand how memory is used, garbage
cleanup issues, etc., but this seems inefficient. Won't a separate copy of
the dataset then exist in memory in each of the class modules and the
calling program until the class objects get disposed of?
It seems to me that it would be more efficent to pass a dataset (or any
large object) ByRef to each class as an argument in the method. For example
in the calling program...
Dim MyDataSet as New DataSet
MyObject.MyMethod(MyDataSet)
'Do stuff
MyDataSet=Nothing
and then in the class...
Public Sub MyMethod (ByRef MyDataSet as DataSet)
'Create or use MyDataSet
End Sub
....so that only one copy of the dataset exists at any point in time. Am I
thinking about this correctly?
In a similar vein, it seems convenient sometimes to write Function Subs that
return an object. But then I wonder whether I have cleanup problems because
you can't dispose of the object inside the Function that creates it, if you
need to return the object. I can dispose of the returned object when I'm
done with it, but do I have a problem with a copy of an object remaining
inside the Function Sub? If so, it seems again that I should pass the
dataset as a ByRef argument.
While on the subject of cleaning up. Can someone explain when/if you need to
use the Dispose method for objects that have them? Again with my dataset,
when I am done with it, is there any advantage to...
MyDataSet.Dispose()
MyDataSet=Nothing
I guess I don't understand what Dispose does that Nothing doesn't already
do.
Thanks in advance,
Chuck
Can anybody set me straight here?
Thanks,
Chuck
4  2115 
Hi Chuck:
"Chuck Ritzke" <CHUCK AT MYACTUARY DOT COM> wrote in message
news:OO**************@TK2MSFTNGP11.phx.gbl... I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth to
a class module?
It really depends.. read on.
For example, say I have a data access module that creates a large
disconnected dataset from a database. I want to pass that dataset back to
the calling program. And then perhaps I want to send that dataset to
another class module.
At first it seems that the "object oriented" approach would be to create a
dataset property in each class module, then run a method that creates the
dataset, and then read the property from the calling program. (and visa
versa if I want to send a dataset to another class module).
This isn't necessarily so. There is a distinction between instance methods
and shard methods. For instance, you can call MessageBox.Show("Blah")
without instantiating an instance of a messagebox. There's nothing unOOP
about this. Many other classes behave similarly and if you look at the File
class it has an instance version FileInfo. In this instance, you may want
to create either a singleton class or similar implementation, or just make
the dataset a Shared (in VB.NET ) or static (in C#) property. Then you
don't need to instantiate an object at all to hold it and it can be
rerferenced from anywhere. Shared/Static properties exist as roots (ignore
that for now, it needs a lot of qualification and if you don't understand
Garbage Collection i'll just confuse you)so they are handled differently
from other objects
Now admittedly, I am not sure I understand how memory is used, garbage
cleanup issues, etc., but this seems inefficient. Won't a separate copy of
the dataset then exist in memory in each of the class modules and the
calling program until the class objects get disposed of?
It's really worth reading up on. Memory management is much different in
..NET than other environments, and it's really something you need to know
about
It seems to me that it would be more efficent to pass a dataset (or any
large object) ByRef to each class as an argument in the method. For
example in the calling program...
I think you are confusing passing By Ref/By Val w2ith Value Types and
Reference Types. Two totally different issues. Passing a Reference Type by
Val passes a reference to it, you aren't passing a copy. DataSets are
Reference Types, so you gain nothing by passing them by Reference (and in
almost every instance, you'll want to avoid this).
Just as a test, create a method that takes a DataTable as a Parameter. In
the first case, fill your datatable so it has rows, then pass it to your
function. IN your function, call datatable.Clear (maybe it's Rows.Clear)
but you want to clear all of the rows. Pass it in ByVal. The next line
after the call to the function, use
MessageBox.Show(MyDataTable.Rows.Count.ToString()) ; //Make sure it had
rows before so you see the distinction. You'll get 0 as the value.
Passing a Reference Type by Val passes a reference to the object, so
whatever you do to it is done to the actual object. This is a critical
point here and it's not the same as VB6 or old VC++ where passing it by Val
passed a Copy. The type (reference vs. value) is critical here and passing
a reference type byVal will yield Totally different results than passing a
Value type by val.
Dim MyDataSet as New DataSet
MyObject.MyMethod(MyDataSet)
'Do stuff
MyDataSet=Nothing
and then in the class...
Public Sub MyMethod (ByRef MyDataSet as DataSet)
'Create or use MyDataSet
End Sub
...so that only one copy of the dataset exists at any point in time. Am I
thinking about this correctly?
I think in this instace, creating it as a Shared Property (since you appear
to be using VB.NET) will solve your problem. You can then reference it from
anywhere and you will only need to reference the shared property. You won't
even need to instantiate a class. You may also want to create it as a
singleton object (google on Singleton VB.NET to get an implementation if you
want to ensure that you only ever have one instance.
In a similar vein, it seems convenient sometimes to write Function Subs
that return an object. But then I wonder whether I have cleanup problems
because you can't dispose of the object inside the Function that creates it, if
you need to return the object. I can dispose of the returned object when I'm
done with it, but do I have a problem with a copy of an object remaining
inside the Function Sub? If so, it seems again that I should pass the
dataset as a ByRef argument.
Once again, DataSets are reference types
While on the subject of cleaning up. Can someone explain when/if you need
to use the Dispose method for objects that have them? Again with my dataset,
when I am done with it, is there any advantage to...
In general, you don't need to call dispose on managed resource. Calling
dispose doesn't mean it's dead. It's only dead after it's been garbage
collected and unless you call GC Manually (which should be avoided unless
you Really know what you are doing and darned sure you want to do this) then
you don't know when or if GC will happen.
MyDataSet.Dispose()
MyDataSet=Nothing
I guess I don't understand what Dispose does that Nothing doesn't already
do.
In this instance, not much. Dispose can do a bunch of cleanup so it depends
on the object's implementation. You can define IDisposable in your own
objects (whether you should and when is another subject). Technically,
Dispose could create 50 new objects although that would be silly. Setting
it to nothing means there are no strong references to it anymore and if you
try, you'll get a null reference exception.
You are asking a lot of good questions, but while I can give you a cursory
answer to them, this isn't a trivial subject. Entire chapters of books and
numerous articles are written on the subject.... Jeffery Richter has a bunch
of great articles on MSDN about it. It'd probably be best if you looked
them over first.
check out Reference Type vs. Value Type
WeakReference
GarbageCollection
IDisposable, Finalize Pattern
MSDn has a ton of articles on this,
http://www.programming-x.com/program...-magazine.html
http://msdn.microsoft.com/msdnmag/is...2/default.aspx
http://www.aleksys.com/aleksys/BookD...ubject_ID=7099
Thanks in advance,
Chuck
Can anybody set me straight here?
Thanks,
Chuck
Hi Chuck:
"Chuck Ritzke" <CHUCK AT MYACTUARY DOT COM> wrote in message
news:OO**************@TK2MSFTNGP11.phx.gbl... I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth to
a class module?
It really depends.. read on.
For example, say I have a data access module that creates a large
disconnected dataset from a database. I want to pass that dataset back to
the calling program. And then perhaps I want to send that dataset to
another class module.
At first it seems that the "object oriented" approach would be to create a
dataset property in each class module, then run a method that creates the
dataset, and then read the property from the calling program. (and visa
versa if I want to send a dataset to another class module).
This isn't necessarily so. There is a distinction between instance methods
and shard methods. For instance, you can call MessageBox.Show("Blah")
without instantiating an instance of a messagebox. There's nothing unOOP
about this. Many other classes behave similarly and if you look at the File
class it has an instance version FileInfo. In this instance, you may want
to create either a singleton class or similar implementation, or just make
the dataset a Shared (in VB.NET ) or static (in C#) property. Then you
don't need to instantiate an object at all to hold it and it can be
rerferenced from anywhere. Shared/Static properties exist as roots (ignore
that for now, it needs a lot of qualification and if you don't understand
Garbage Collection i'll just confuse you)so they are handled differently
from other objects
Now admittedly, I am not sure I understand how memory is used, garbage
cleanup issues, etc., but this seems inefficient. Won't a separate copy of
the dataset then exist in memory in each of the class modules and the
calling program until the class objects get disposed of?
It's really worth reading up on. Memory management is much different in
..NET than other environments, and it's really something you need to know
about
It seems to me that it would be more efficent to pass a dataset (or any
large object) ByRef to each class as an argument in the method. For
example in the calling program...
I think you are confusing passing By Ref/By Val w2ith Value Types and
Reference Types. Two totally different issues. Passing a Reference Type by
Val passes a reference to it, you aren't passing a copy. DataSets are
Reference Types, so you gain nothing by passing them by Reference (and in
almost every instance, you'll want to avoid this).
Just as a test, create a method that takes a DataTable as a Parameter. In
the first case, fill your datatable so it has rows, then pass it to your
function. IN your function, call datatable.Clear (maybe it's Rows.Clear)
but you want to clear all of the rows. Pass it in ByVal. The next line
after the call to the function, use
MessageBox.Show(MyDataTable.Rows.Count.ToString()) ; //Make sure it had
rows before so you see the distinction. You'll get 0 as the value.
Passing a Reference Type by Val passes a reference to the object, so
whatever you do to it is done to the actual object. This is a critical
point here and it's not the same as VB6 or old VC++ where passing it by Val
passed a Copy. The type (reference vs. value) is critical here and passing
a reference type byVal will yield Totally different results than passing a
Value type by val.
Dim MyDataSet as New DataSet
MyObject.MyMethod(MyDataSet)
'Do stuff
MyDataSet=Nothing
and then in the class...
Public Sub MyMethod (ByRef MyDataSet as DataSet)
'Create or use MyDataSet
End Sub
...so that only one copy of the dataset exists at any point in time. Am I
thinking about this correctly?
I think in this instace, creating it as a Shared Property (since you appear
to be using VB.NET) will solve your problem. You can then reference it from
anywhere and you will only need to reference the shared property. You won't
even need to instantiate a class. You may also want to create it as a
singleton object (google on Singleton VB.NET to get an implementation if you
want to ensure that you only ever have one instance.
In a similar vein, it seems convenient sometimes to write Function Subs
that return an object. But then I wonder whether I have cleanup problems
because you can't dispose of the object inside the Function that creates it, if
you need to return the object. I can dispose of the returned object when I'm
done with it, but do I have a problem with a copy of an object remaining
inside the Function Sub? If so, it seems again that I should pass the
dataset as a ByRef argument.
Once again, DataSets are reference types
While on the subject of cleaning up. Can someone explain when/if you need
to use the Dispose method for objects that have them? Again with my dataset,
when I am done with it, is there any advantage to...
In general, you don't need to call dispose on managed resource. Calling
dispose doesn't mean it's dead. It's only dead after it's been garbage
collected and unless you call GC Manually (which should be avoided unless
you Really know what you are doing and darned sure you want to do this) then
you don't know when or if GC will happen.
MyDataSet.Dispose()
MyDataSet=Nothing
I guess I don't understand what Dispose does that Nothing doesn't already
do.
In this instance, not much. Dispose can do a bunch of cleanup so it depends
on the object's implementation. You can define IDisposable in your own
objects (whether you should and when is another subject). Technically,
Dispose could create 50 new objects although that would be silly. Setting
it to nothing means there are no strong references to it anymore and if you
try, you'll get a null reference exception.
You are asking a lot of good questions, but while I can give you a cursory
answer to them, this isn't a trivial subject. Entire chapters of books and
numerous articles are written on the subject.... Jeffery Richter has a bunch
of great articles on MSDN about it. It'd probably be best if you looked
them over first.
check out Reference Type vs. Value Type
WeakReference
GarbageCollection
IDisposable, Finalize Pattern
MSDn has a ton of articles on this,
http://www.programming-x.com/program...-magazine.html
http://msdn.microsoft.com/msdnmag/is...2/default.aspx
http://www.aleksys.com/aleksys/BookD...ubject_ID=7099
Thanks in advance,
Chuck
Can anybody set me straight here?
Thanks,
Chuck
Thanks very much Bill for the detailed response. That definitely points out
some misconceptions I had and points me to some things to look
Thanks again,
Chuck
"William Ryan eMVP" <bi**@NoSp4m.devbuzz.com> wrote in message
news:ub**************@TK2MSFTNGP09.phx.gbl... Hi Chuck:
"Chuck Ritzke" <CHUCK AT MYACTUARY DOT COM> wrote in message
news:OO**************@TK2MSFTNGP11.phx.gbl... I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth
to a class module?
It really depends.. read on.
For example, say I have a data access module that creates a large
disconnected dataset from a database. I want to pass that dataset back
to the calling program. And then perhaps I want to send that dataset to
another class module.
At first it seems that the "object oriented" approach would be to create
a dataset property in each class module, then run a method that creates
the dataset, and then read the property from the calling program. (and visa
versa if I want to send a dataset to another class module).
This isn't necessarily so. There is a distinction between instance
methods and shard methods. For instance, you can call MessageBox.Show("Blah")
without instantiating an instance of a messagebox. There's nothing unOOP
about this. Many other classes behave similarly and if you look at the
File class it has an instance version FileInfo. In this instance, you may want
to create either a singleton class or similar implementation, or just make
the dataset a Shared (in VB.NET ) or static (in C#) property. Then you
don't need to instantiate an object at all to hold it and it can be
rerferenced from anywhere. Shared/Static properties exist as roots
(ignore that for now, it needs a lot of qualification and if you don't understand
Garbage Collection i'll just confuse you)so they are handled differently
from other objects
Now admittedly, I am not sure I understand how memory is used, garbage
cleanup issues, etc., but this seems inefficient. Won't a separate copy
of the dataset then exist in memory in each of the class modules and the
calling program until the class objects get disposed of? It's really worth reading up on. Memory management is much different in
.NET than other environments, and it's really something you need to know
about
It seems to me that it would be more efficent to pass a dataset (or any
large object) ByRef to each class as an argument in the method. For
example in the calling program...
I think you are confusing passing By Ref/By Val w2ith Value Types and
Reference Types. Two totally different issues. Passing a Reference Type
by Val passes a reference to it, you aren't passing a copy. DataSets are
Reference Types, so you gain nothing by passing them by Reference (and in
almost every instance, you'll want to avoid this).
Just as a test, create a method that takes a DataTable as a Parameter. In
the first case, fill your datatable so it has rows, then pass it to your
function. IN your function, call datatable.Clear (maybe it's Rows.Clear)
but you want to clear all of the rows. Pass it in ByVal. The next line
after the call to the function, use
MessageBox.Show(MyDataTable.Rows.Count.ToString()) ; //Make sure it had
rows before so you see the distinction. You'll get 0 as the value.
Passing a Reference Type by Val passes a reference to the object, so
whatever you do to it is done to the actual object. This is a critical
point here and it's not the same as VB6 or old VC++ where passing it by
Val passed a Copy. The type (reference vs. value) is critical here and
passing a reference type byVal will yield Totally different results than passing a
Value type by val.
Dim MyDataSet as New DataSet
MyObject.MyMethod(MyDataSet)
'Do stuff
MyDataSet=Nothing
and then in the class...
Public Sub MyMethod (ByRef MyDataSet as DataSet)
'Create or use MyDataSet
End Sub
...so that only one copy of the dataset exists at any point in time. Am
I thinking about this correctly?
I think in this instace, creating it as a Shared Property (since you
appear to be using VB.NET) will solve your problem. You can then reference it
from anywhere and you will only need to reference the shared property. You
won't even need to instantiate a class. You may also want to create it as a
singleton object (google on Singleton VB.NET to get an implementation if
you want to ensure that you only ever have one instance.
In a similar vein, it seems convenient sometimes to write Function Subs that return an object. But then I wonder whether I have cleanup problems
because you can't dispose of the object inside the Function that creates it, if
you need to return the object. I can dispose of the returned object when I'm
done with it, but do I have a problem with a copy of an object remaining
inside the Function Sub? If so, it seems again that I should pass the
dataset as a ByRef argument.
Once again, DataSets are reference types
While on the subject of cleaning up. Can someone explain when/if you
need to use the Dispose method for objects that have them? Again with my
dataset, when I am done with it, is there any advantage to...
In general, you don't need to call dispose on managed resource. Calling
dispose doesn't mean it's dead. It's only dead after it's been garbage
collected and unless you call GC Manually (which should be avoided unless
you Really know what you are doing and darned sure you want to do this)
then you don't know when or if GC will happen.
MyDataSet.Dispose()
MyDataSet=Nothing
I guess I don't understand what Dispose does that Nothing doesn't
already do.
In this instance, not much. Dispose can do a bunch of cleanup so it
depends on the object's implementation. You can define IDisposable in your own
objects (whether you should and when is another subject). Technically,
Dispose could create 50 new objects although that would be silly. Setting
it to nothing means there are no strong references to it anymore and if
you try, you'll get a null reference exception.
You are asking a lot of good questions, but while I can give you a cursory
answer to them, this isn't a trivial subject. Entire chapters of books
and numerous articles are written on the subject.... Jeffery Richter has a
bunch of great articles on MSDN about it. It'd probably be best if you looked
them over first.
check out Reference Type vs. Value Type
WeakReference
GarbageCollection
IDisposable, Finalize Pattern
MSDn has a ton of articles on this,
http://www.programming-x.com/program...-magazine.html
http://msdn.microsoft.com/msdnmag/is...2/default.aspx
http://www.aleksys.com/aleksys/BookD...ubject_ID=7099
Thanks in advance,
Chuck
Can anybody set me straight here?
Thanks,
Chuck
Thanks very much Bill for the detailed response. That definitely points out
some misconceptions I had and points me to some things to look
Thanks again,
Chuck
"William Ryan eMVP" <bi**@NoSp4m.devbuzz.com> wrote in message
news:ub**************@TK2MSFTNGP09.phx.gbl... Hi Chuck:
"Chuck Ritzke" <CHUCK AT MYACTUARY DOT COM> wrote in message
news:OO**************@TK2MSFTNGP11.phx.gbl... I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth
to a class module?
It really depends.. read on.
For example, say I have a data access module that creates a large
disconnected dataset from a database. I want to pass that dataset back
to the calling program. And then perhaps I want to send that dataset to
another class module.
At first it seems that the "object oriented" approach would be to create
a dataset property in each class module, then run a method that creates
the dataset, and then read the property from the calling program. (and visa
versa if I want to send a dataset to another class module).
This isn't necessarily so. There is a distinction between instance
methods and shard methods. For instance, you can call MessageBox.Show("Blah")
without instantiating an instance of a messagebox. There's nothing unOOP
about this. Many other classes behave similarly and if you look at the
File class it has an instance version FileInfo. In this instance, you may want
to create either a singleton class or similar implementation, or just make
the dataset a Shared (in VB.NET ) or static (in C#) property. Then you
don't need to instantiate an object at all to hold it and it can be
rerferenced from anywhere. Shared/Static properties exist as roots
(ignore that for now, it needs a lot of qualification and if you don't understand
Garbage Collection i'll just confuse you)so they are handled differently
from other objects
Now admittedly, I am not sure I understand how memory is used, garbage
cleanup issues, etc., but this seems inefficient. Won't a separate copy
of the dataset then exist in memory in each of the class modules and the
calling program until the class objects get disposed of? It's really worth reading up on. Memory management is much different in
.NET than other environments, and it's really something you need to know
about
It seems to me that it would be more efficent to pass a dataset (or any
large object) ByRef to each class as an argument in the method. For
example in the calling program...
I think you are confusing passing By Ref/By Val w2ith Value Types and
Reference Types. Two totally different issues. Passing a Reference Type
by Val passes a reference to it, you aren't passing a copy. DataSets are
Reference Types, so you gain nothing by passing them by Reference (and in
almost every instance, you'll want to avoid this).
Just as a test, create a method that takes a DataTable as a Parameter. In
the first case, fill your datatable so it has rows, then pass it to your
function. IN your function, call datatable.Clear (maybe it's Rows.Clear)
but you want to clear all of the rows. Pass it in ByVal. The next line
after the call to the function, use
MessageBox.Show(MyDataTable.Rows.Count.ToString()) ; //Make sure it had
rows before so you see the distinction. You'll get 0 as the value.
Passing a Reference Type by Val passes a reference to the object, so
whatever you do to it is done to the actual object. This is a critical
point here and it's not the same as VB6 or old VC++ where passing it by
Val passed a Copy. The type (reference vs. value) is critical here and
passing a reference type byVal will yield Totally different results than passing a
Value type by val.
Dim MyDataSet as New DataSet
MyObject.MyMethod(MyDataSet)
'Do stuff
MyDataSet=Nothing
and then in the class...
Public Sub MyMethod (ByRef MyDataSet as DataSet)
'Create or use MyDataSet
End Sub
...so that only one copy of the dataset exists at any point in time. Am
I thinking about this correctly?
I think in this instace, creating it as a Shared Property (since you
appear to be using VB.NET) will solve your problem. You can then reference it
from anywhere and you will only need to reference the shared property. You
won't even need to instantiate a class. You may also want to create it as a
singleton object (google on Singleton VB.NET to get an implementation if
you want to ensure that you only ever have one instance.
In a similar vein, it seems convenient sometimes to write Function Subs that return an object. But then I wonder whether I have cleanup problems
because you can't dispose of the object inside the Function that creates it, if
you need to return the object. I can dispose of the returned object when I'm
done with it, but do I have a problem with a copy of an object remaining
inside the Function Sub? If so, it seems again that I should pass the
dataset as a ByRef argument.
Once again, DataSets are reference types
While on the subject of cleaning up. Can someone explain when/if you
need to use the Dispose method for objects that have them? Again with my
dataset, when I am done with it, is there any advantage to...
In general, you don't need to call dispose on managed resource. Calling
dispose doesn't mean it's dead. It's only dead after it's been garbage
collected and unless you call GC Manually (which should be avoided unless
you Really know what you are doing and darned sure you want to do this)
then you don't know when or if GC will happen.
MyDataSet.Dispose()
MyDataSet=Nothing
I guess I don't understand what Dispose does that Nothing doesn't
already do.
In this instance, not much. Dispose can do a bunch of cleanup so it
depends on the object's implementation. You can define IDisposable in your own
objects (whether you should and when is another subject). Technically,
Dispose could create 50 new objects although that would be silly. Setting
it to nothing means there are no strong references to it anymore and if
you try, you'll get a null reference exception.
You are asking a lot of good questions, but while I can give you a cursory
answer to them, this isn't a trivial subject. Entire chapters of books
and numerous articles are written on the subject.... Jeffery Richter has a
bunch of great articles on MSDN about it. It'd probably be best if you looked
them over first.
check out Reference Type vs. Value Type
WeakReference
GarbageCollection
IDisposable, Finalize Pattern
MSDn has a ton of articles on this,
http://www.programming-x.com/program...-magazine.html
http://msdn.microsoft.com/msdnmag/is...2/default.aspx
http://www.aleksys.com/aleksys/BookD...ubject_ID=7099
Thanks in advance,
Chuck
Can anybody set me straight here?
Thanks,
Chuck
This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics | |
by: DrUg13 |
last post by:
In java, this seems so easy. You need a new object
Object test = new Object() gives me exactly what I want.
could someone please help me understand the different ways to do the
same thing in...
|
by: wrecker |
last post by:
Hi all,
I have a few common methods that I need to use at different points in
my web application. I'm wondering where the best place would be to
put these? I think that I have three options.
...
|
by: jojobar |
last post by:
Hello,
I am trying to use vs.net 2005 to migrate a project originally in vs.net
2003. I started with creation of a "web site", and then created folders for
each component of the site.
I read...
|
by: David Helgason |
last post by:
I think those best practices threads are a treat to follow (might even
consider archiving some of them in a sort of best-practices faq), so
here's one more.
In coding an game asset server I want...
|
by: Chuck Ritzke |
last post by:
I keep asking myself this question as I write class modules. What's the
best/smartest/most efficient way to send a large object back and forth to a
class module?
For example, say I have a data...
| | |
by: Rex |
last post by:
Hi All - I have a question that I think MIGHT be of interest to a
number of us developers. I am somewhat new to VIsual Studio 2005 but
not new to VB. I am looking for ideas about quick and...
|
by: 2005 |
last post by:
Hi
In C++, are the following considered best practices or not?
- passing aguments to functions (ie functions do not take any arguments
)
- returning values using return statement
Anything...
|
by: shamirza |
last post by:
Question
Do ActiveX DLLs made in VB still need the VB runtimes on
the
machine?
________________________________________
Answer
In a word, Yes.
Visual Basic does not support what is known...
|
by: Jim |
last post by:
Hi guys,
I have an object which represents an "item" in a CMS "component" where
an "item" in the most basic form just a field, and a "component" is
effectively a table.
"item" objects can be...
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...
|
by: Hystou |
last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can...
| | |
by: tracyyun |
last post by:
Dear forum friends,
With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each...
|
by: agi2029 |
last post by:
Let's talk about the concept of autonomous AI software engineers and no-code agents. These AIs are designed to manage the entire lifecycle of a software development project—planning, coding, testing,...
|
by: TSSRALBI |
last post by:
Hello
I'm a network technician in training and I need your help.
I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs.
The...
|
by: adsilva |
last post by:
A Windows Forms form does not have the event Unload, like VB6. What one acts like?
|
by: 6302768590 |
last post by:
Hai team
i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated ...
|
by: muto222 |
last post by:
How can i add a mobile payment intergratation into php mysql website.
| | |
by: bsmnconsultancy |
last post by:
In today's digital era, a well-designed website is crucial for businesses looking to succeed. Whether you're a small business owner or a large corporation in Toronto, having a strong online presence...
| | |
