Free dal software for windows

DAG 1.0.1 comes as a sophisticated visual development tool which can generate the data access layer code for three-tiered and N-tiered applications built using the Microsoft .Net 2.0 framework and SQL2005. The tool creates select, update, delete and insert stored procedures and generates data access code that can be included in the project and accessed via an DAL API.

Major Features:

1. Reduce writing monotonous Data Access Code;
2. Regenerate the entire Data Access Code at the click of a button;
3. Redesign your Database without having to make changes to the Data Access Layer;
4. Creates DAL code for custom Stored procedure;
5. Writes human readable code so you can easily follow and understand it;
6. Easy to learn in less than a few hours;
7. Get perfect code every time no need to debug DAL plumbing issues;
8. Even creates select, update, delete and insert stored procedures for all tables;
9. Easy to extend and modify the code templates to suite your requirements.
   

Maxthon add-on that will allow you to scroll your currently opened webpage in the direction arrow ScrollPAD is a plugin that will scroll the current page when the mouse moves over the direction arrow. It has the ability to scroll in 8 directions. Also, there is an optional subtool called X-PAD - its a floating window that can be placed anywhere on the screen.
Users can set their own scrolling speed and scrolling amount.
System requirements:
- Maxthon 1.0.0178+

Maxthon add-on that will insert a user-customizable library item into a selected text box on the web page MyLibrary is a plugin that will add a predefined library item to a selected text box/input area in a webpage. It can be used as a manual form filler tool, an archieve/database for frequently used texts, a coding tool, and for many other purposes.
The plugin can add a library item to the beginning or the end of the original text box content. MyLibrary remembers the last selected item and this last item is selected on load.Users can create their own libraries and use them in the plugin.
System requirements:
- Maxthon 1.0.0168+

Maxthon add-on that will add a tab indexer and navigator with tab preview ability to your sidebar Tabigator is a plugin that will add a tab indexer and navigator with tab preview ability to your sidebar. Tabigator lists all open tab "titles" as links (optionally with tab previews) vertically on Maxthon sidebar and provides a different tab control method.
From the entries, users can close, print, refresh, add to favorites, duplicate, copy URL to clipboard, save as HTML
and move back-forward any of the desired tabs. Any of those action buttons can be hidden through Settings. The actions can also be activated through the context menu of the tab entry.
The plugin has an optional auto refresh ability which can be adjusted to any time interval. Users can set the maximum length of the link text. For example you can use 0 to display only tab number.
There is an optional Info Window (at user-defined size) which shows some information about the pages (Title, URL, Last Modified date, file size, domain, referrer).
The tab list entries can be highlighted with custom colors. Users can change the background and text colors by editing highlight.js file with a text editor such as NotePad (instructions are in the file).
System requirements:
- Maxthon 1.0.0168+

DataObjects.NET is a useful and reliable .NET library which dramatically simplifies development of data and business tiers of the database application. It provides:
Methodology that standardizes and simplifies development of persistent classes and services operating with them providing very clear separation of your business and data tiers from other parts of an application. Essentially DataObjects.NET requires you to build a hierarchy of your persistent and business objects over two base classes: DataObject and DataService. It provides more then 20 attributes controlling almost any persistence or behavior-related aspect. Dont worry about this number - you can know nearly 5 of them to start using DataObjects.NET.
Persistence framework handling all object persistence related tasks transparently. Moreover, this framework allows to almost forget that the underlying database exists - it handles even database schema updates. This framework fully supports inheritance, persistent interfaces, relations and collections, object queries, full-text indexing and search, multilingual properties and a lot of other features. Use of this framework makes most part of your data tier automatically compatible with Microsoft SQL Server 2005 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) (free, but one of the most featured database servers) without any additional code.
Transactional services allowing to almost forget that your business and data objects operate in the concurrent transactional environment. Transactional services intercept calls of your business tier methods and wraps them into transactions (outermost or nested) providing that if exception or deadlock occurs, no data will be changed. These services are capable of re-processing method call on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless its highly configurable.
Security system supporting per-instance access control lists (allow-deny lists), permissions (custom permissions), security principals (users and roles) and permission inheritance. Its primary goal is to make usage of business objects completely safe, even when these objects are publicly available - via .NET Remoting, for example.
All is initially remotable - any persistent object or business service can be marshaled to another application domain via .NET Remoting (as well as all other DataObjects.NET-related objects, e.g. Query). This means that you can access your data and business tier from a completely different network or across the Internet with almost no additional code. DataObjects.NET supports two marshalling scenarios: access-by-reference for regular DataObjects and by-value marshalling for so-called offline entities (data transfer objects).
Main features:
- Transparent persistence: you dont need to write data access code for insertupdatedelete operations - DataObjects.NET persists instances transparently for you. This means that you should never think about invoking a SaveLoad-like methods also - DataObjects.NET handles such tasks completely transparently making you fell youre working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldnt worry about persisting your changes. Note that this doesnt mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
- Automatic database schema buildingupgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of Domain its database can be upgraded to support new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). Upgrade process doesnt destroy existing data.
- Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances; upcoming versions will support GUID and 32-bit integers also.
- Querying: use DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances youre interested in. An example of DataObjects.NET query: "Select Animal instances where {LegCount}=4 order by {Name}" - this query fetches all four-legged Animal instances, as well as instances of Animal descendants - e.g. Cats and Dogs). More difficult example selecting grandparents instances: "Select Animal instances where {Children[{Children.count}>0].count}>0". DataObjects.NET query language supports sub-queries, joins, distinct and full-text search part in criteria.
- Inheritance support: as it was mentioned, DataObjects.NET fully supports inheritance for persistent classes. But we went much further here: DataObjects.NET supports so-called persistent interfaces. This unique feature allows you to query for objects implementing some interface and refer to its persistent properties inside query criteria.
- Highly configurable persistence for instance properties:
- Multilingual properties (unique feature): you can mark any property with [Translatable] attribute to specify that it should store independent versions of its value for each Culture registered in you Domain. This and a set of other features dramatically simplifies development of multilingual database applications
- References: dont worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if youll try to delete the grandCat instance after executing this code, cat will be notified (because it holds a reference to grandCat). Also after grandCat deletion cat.Parent will be automatically set to null
- Collections: cat.Children.Add(kittyCat). Paired collections and reference properties (unique feature) are supported (so kittyCat.Parent can be automatically set to cat for the code above). "Contained" collections and references are supported as well (if cat.Children is marked by [Contained] attribute, all instances referenced by Children collection will be deleted on cats deletion)
- Structs: any struct type can be used as type of persistent property or item of collection. DataObjects.NET persists such properties into multiple database columns according to the structure of struct type.
- [Serializable] properties: properties which type is marked by [Serializable] attribute are persisted without any additional coding - theyre stored as byte streams (BLOBs). DataObjects.NET handles references to other persistent entities inside such serialized graphs in a special way making them to point to appropriate instances on each deserialization (note that DataObjects.NET is transactional, so you can find different versions of the same persistent instance in different sessions)
- SQL-related attributes are available for almost any type of persistent properties ([SqlType], [Length] and similar ones)
- Indexing: you can apply [Indexed] attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use [Index] attribute to describe a compound index
- Full-text indexing & search (unique feature): DataObjects.NET supports full-text indexing and search. Microsoft Search (available for SQL Server 20052000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. Built-in managed wrapper for Microsoft Index Service filters helps to index almost any documentfile type stored in database or externally. In particular, you can index the following document types: Microsoft Office files (.doc, .dot, .rtf, .xls, .ppt, etc...), HTML files (.htm, .html), Adobe PDF files and so on.
- Built-in NTFS-like security system (unique feature): DataObjects.NET has extremely powerful security system allowing to define the permission for any action (e.g. method execution or property access), grant or deny it for a set of security principals (users and roles) on some persistent instances (like on folders in NTFS) and enforce its presence by demanding it inside methods or property assessors of persistent types or DataServices. It brings NTFS-like security into your business tier with almost zero additional coding!
- We want to underline two very important features of this subsystem:
- Performance: security system is extremely fast - all passed permission demands are cached, effective permission sets for any cached DataObject instance are cached too, internal security notification layer allows any cached DataObject instance to notify all dependent cached instances on changes in its effective permission set... Normally a subsequent permission demand on the same instance is quite fast. This allows DataObjects.NET to execute up to 4000000 permission demands per second on 2,8GHz P4! Its almost impossible to implement a security system having the similar features and performance without implementing all other caching features DataObjects.NET has. Just imagine the nightmare of implementing the similar part in your DAL!
- Immediate effect: all security restrictions take effect immediately on any security-related changes in Session - so its not necessary to reopen Session invoke some method to apply new security restrictions. When you adding a User to some Role, granting permission for him or for some role it belongs to, this immediately affects on its security restrictions in the current Session - so all is transparent even in this case. Even rollback of nested transaction (or rollback to savepoint) immediately affects on security restrictions.
- Rich data import and export capabilities:
- Serialization: DataObjects.NET completely supports .NET Serialization, so you can serialize or deserialize a graph with persistent instances using binary or SOAP formatters. Custom formatters are supported as well.
- Adapter component exports persistent instances to DataSet and imports back the changes
- Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) pattern. It allows to export a set of DataObject instances to serializable, marshal-by-value ObjectSets, pass them to the client to operate with them locally and propagate the changes made to them back to the application server
- BindingManager component (unique feature) establishes two-way bindings between ASP.NETWindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings - we think this approach is also interesting for developers
- All importexport tools support VersionIDVersionCode validation (optimistic updates)
- Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if its turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 2000 driver only.
- Automatic transactions (unique feature - it quite differs from standard COM+ automatic transactions, read more about it further): DataObjects.NET is completely transactional. It supports automatic transactions (started with a method call or property access and committed or rolled back based on result; transactional behavior is controlled by attributes) as well as manual transactions (you can also start/commit/rollback a transaction manually); nested transactions and savepoints are also supported.
- Transparent deadlock handling (unique feature): in a highly concurrent environment deadlocks are regular. In case of a deadlock one of the deadlocked transactions (deadlock victim) is aborted by the database server. Normally it should be re-executed later by the application - this situation is called "deadlock handling". DataObjects.NET is capable of handling deadlocks transparently - if a deadlock occurs during an automatic transaction, it can be transparently handled by re-processing of the outermost transaction (re-calling of corresponding method).
- Data services (unique feature) allows to use all DataObjects.NET transactional capabilities (automatic transactions, transparent deadlock handling) with non-persistent classes (DataService descendants). This feature greatly simplifies development of services operating with persistent instances. Its very convenient to use this conception to develop common services of an application, such as Logging Service. Data services are very close to ServicedComponents of .NET, the difference is that they are much faster (method calls are intercepted by the runtime proxies rather then .NET transparent proxies, no COM+ services are used) and easier to use.
- Runtime services (unique feature) are data services of special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside Domain. The purpose of runtime services is to perform various maintenance tasks periodically. For example, all IFtIndexer implementors are runtime services that periodically update full-text indexes.

Maxthon add-on that will help you extract the images contained in the webpage from your current tab IMG Extractor is a plugin that will extract the images from a webpage and display them in a new one. Works with frames and iframes. Each frame images are displayed in separate pages.
Note: IMG Extractor wont work if there are no IMG tags in the page.
System requirements:
- Maxthon 1.0.0178+

Maxthon add-on that will give you access to a set of URL copy tools for your browser Copy URL Tools is a plugin that will copy the tabs URLs to clipboard, will save them in a file and more.
Main features:
- Default: will copy the current tabs URL to clipboard
- Copy All Tab URLs: Copies All Tab URLs
- Write All Tab URLs to Text: Prompts a file name and creates a file with that name under Maxthon/Plugin/Copy URL/saved_data folder containing all tab URLs
- Display All Tab URLs: opens a new browser window and lists the current tabs URLs
System requirements:
- Maxthon 1.0.0178+