newObjects (fromerly known as ZmeY soft) NetStreams
Home Products Development
pixel.gif (49 bytes)
Products by category
ALP area
ISAPI filters
Forums (discussions)
Articles and samples
Code snippets
A little help

Read more ...
Click here
ALP is implemented as an Asynchronous Pluggable Protocol. It acts like a WEB server but without need of network. It executes WEB applications such as ASP pages and CGI applications. ALP makes Internet Explorer to be server and client. With ALP you can write stand-alone desktop applications, CD-ROM autoruns, use ASP for pure desktop software and still keep your code ready to run on WEB servers too.
Write desktop software in ASP and CGI!
download it

Webscripts directory

Site navigation
ActiveX components

Licensing types legend
(M) Single machine license
(U) Unlimited per-company license
(D) Unlimited development license
(S) Special type of licensing

PADRING: Always new software

Quick contact

Active visitors
Suggested links
Suggest this page to the other visitors. Click the button below to place this page in the list above .

Price: FREEWARE Discount for resalers FREEWARE
Information Download Buy
Download (PC,CE,PPC etc.)
Documentation (NDL SFX install)
Documentation (NDL Zipped)


Related products and tools
Script any ActiveX in Pocket IE
ActiveX Pack1
About 30 components for CE and desktop. NetStreams needs it.
Active Local Pages
Write desktop applications in ASP and CGI.
CE App manager Inovker
You may need this for your Pocket PC installations.
Script service
If you want to build Windows NT/XP service in script.
newObjects Development Library - combined documentation.

The NetStreams library comes as first from many planned extensions to the newObjects ActiveX Pack1. The ActiveX Pack1 library provides some utility objects (like SFStream, SFStorage, SFRecord and so on) which are intended to work over abstract standardized functionality provided by other libraries. In the case of the NetStreams library this is mostly about the stream abstraction which is provided in Windows over the IStream COM interface. Thus NetStreams provides a set of objects designed to perform the operations application will need in order to establish a connection to another network node or infrared device for example. This includes address operations, device lookups and so on. The application usually does what is needed and then at certain point creates or accepts a connection represented by the NetStream's SocketStream object. This object implements the IStream functionality appropriate for network and IRDA connections (non-seekable stream) and can be used in turn through SFStream object attached to it for input/output operations. This allows all the functionality (of the ActiveX Pack1) designed for non-seekable streams to be used over network connections as well as it is used over files, memory streams or other resources behaving like streams/files. In C++ or other low level COM enabled applications the SocketStream object can be queried for its IStream interface and it can be used to perform the transfer.

The NetStreams library includes TCP/IP V4/V6 and IRDA support. It is based on WinSock 1.1 for maximum cross-platform compatibility. Another version based on WinSock 2 will be released later with support for more protocols and medias (such as Bluetooth), but it will have narrowed area of compatibility (for example it will not support Windows CE devices based on version lower than 4.0). Therefore, we decided to start this line of components with the library which covers most of the PC-s, Pocket PC-s and devices and then continue with the more specific implementations. The latter is far more important for the Windows CE devices where much more older devices are still in active usage and even manufactured at this very moment with stripped down OS versions or old ones (saving memory sometimes justifies such decisions).

What to download?

There is a installable package for the most popular platforms (PC and Pocket PC). It contains the binaries for these platforms and installer. The other binaries (and also copies of the binary files included in the installable package) are packed in separate ZIP files - one for each platform. The separate binaries will require manual installation which requires only copying the DLL (and some samples if desired) to the device and then registering the DLL using the regsvr32.exe/regsvrce.exe (provided by MS in the SDK) or using the Microhost from newObjects ActiveX Pack1. See more information in the readme file in the downloaded archive. Note you need newObjects ActiveX Pack1 installed on the machine/device where the NetStreams will be used in order to run the sample scripts and write yours. Only the microhost versions of the samples can be run on all the platforms without changes - the Windows Scripting Host from Microsoft is not available for Pocket PC and the samples for it are desktop only (However a simulation for it can be built in script for microhost).

Documentation: Complete documentation is included in the latest newObjects Development Library. You will need to install it in order to access the reference information.

The library is available for the most platforms (desktop and Pocket PC). It requires newObjects ActiveX Pack1 for usage in scripting and VB based applications and WinSock 1.1 support on the system (which requirement is met by default on all the supported platforms).

What you can do with NetStreams?

Easily create client or/and server applications in script, VB, C++ and so on. Primary targets for the NetStreams are the scripting environments and Visual Basic (including embedded version), but there is no limitation and in some cases it may help even C++ projects to implement various different tasks using a single technique (for instance managing files, network connections, compression and other stuff in the same way). The components usage may be beneficial in mixed applications - e.g. applications that implement script hosting capabilities to allow custom extensions. In such case usage of the NetStreams and some synchronization objects from newObjects ActiveX Pack1 opens the opportunity to share these objects between the C++ part and the script part of the applications for example.

Examples? A simple WEB server (you can see these in the samples included in the archive) can be implemented in only 3-4k of VBScript code. Various tools or application extensions can be implemented that work for example with POP3, IMAP, FTP or other servers. And all this can be done fully in script (by using both ActiveX Pack1 and NetStreams together). See for additional examples on the download page.  

Usage considerations.

Many developers may think that usage of a specially built component for mail fetching, HTTP or FTP operations for example is a better way then having a scripting component (based on WSC or on Composite objects techniques from AXPack1) or an include script file/code. Well, it may be easier in the beginning, but this gives the developer no way to change or extend the components, no need to mention that very often such components cost a lot. If there is a mistake in such a component almost nothing can be done. With NetStreams and newObejcts ActiveX Pack1 the developer has the basic functionality that really must be implemented in C++ or another low level language packed in components and only the high level tasks must be done in script, VB or other high level development environment. In fact the scripting languages are even better than C++ for such kind of usage (for example parsing commands and implementing logic over them). In many cases this may even produce better results than a component built fully in C++. If nothing else it has more chances to be bug free because the functionality is separated in two levels which are both much simpler. Also the ability to change the logic of the high level operations allows the developer to adapt the code for tasks or specifics not initially planned without need to dig into the low level communication code and deal with buffer problems, bug traps and so on.

So the key aim for NetStreams (and respectively for the entire ActiveX Pack1 family) is to separate the functionality levels just where they must be separated in order to make the programming easier and yet more powerful. We hope we are close to the right decision about the this and giving it for free will make these libraries a trusted base for further development.


NetStreams follows the ActiveX Pack1 concepts - i.e. it is free without guaranteed support. In fact we treat ourselves as we treat the other developers - you can include the library in your products and we can do so. We provide support for newObjects ActiveX Pack1 and its family for all our commercial products where these library are included as core part, run-time library or another kind of integral part. If you already own a license for one of them you are entitled for full e-mail based support for the newObjects ActiveX Pack1 and its family (incl. NetStreams) and you can pass it to your customers as needed. Our decision is based on the fact that such multipurpose libraries are in fact an API (Application Programming Interface) and it must be accessible for the developers if possible without need to pay royalties. The popularity and the freedom of the API enables you to deploy it wherever it may be needed with or without our products and indirectly it provides easy ways to gain compatibility and cross-compatibility. This ensures everyone who uses the techniques introduced in our products will be able to employ them or compatibility with them in other products by using only freeware components. We hope this is of common benefit for all the developers.

Copyright newObjects (ZmeY soft) 2001