"Это не резюме - это
кусок пояснений который был послан клиенту
вместе с резюме"
Спасибо DP, взято с http://www.privet.com/forum/viewtopic.php?t=23012
Document: Implementation Architecture
Application: <removed>
Company: <removed>
Period: January 2001 - July 2002
Language: C++
Modules Description
1. Client Module
User interface to browse data, send requests to the engine
and receive notifications from the engine.
Implemented as executable, MFC/GUI implementation, hosting
custom(third party controls like data grids, etc.)controls.
Requests to the engine are asynchronous,
through the communication module.
2. Calculation Engine
Executable, implements the business logic through pluggable
customer dependant DLLs. Pulls periodically the data from
the Clock Terminal.
Runs as NT service.
Establish RPC(RPC over TCP/IP, Named Pipes and Local RPC)
connection with the communication modules.
Main Components:
- Engine Manager - singleton object to maintain/sychronize the
connections and requests.
- Thread Scheduler - singleton object,
maintains the thread pool with worker threads
(one thread per processing DLL)
- Queue Manager - singleton object to maintain the client requests
and send back notifications per client context
and type of request.
- Data Adapter - objects to handle data request
(insert, delete, update and select direct SQL
statements) from the engine(through processing Dlls)
to Microsoft SQL Server
Exploits ADO and connection pooling
(per thread/transaction context)
3. Communication module
Implemented as DLL.
Runs in the process address space of the client module.
Maintains the communication between the client and the engine.
Establish sink interface to handle callbacks from the engine
to the clients.
4. Tracing/Debug Module
Implemented as console application. Accepts the trace data from the
engine
(through mail slots - one way communication) and displays the data to the
console.
Useful for diagnostics, since the engine runs as a service and does not
have
GUI or console interface.
5. Clock Terminal - third party software
Acceptts and records the main data stream - employee badge swipes.
Implemtation for Microsoft .NET Framework, with C# language
-----------------------------------------------------------
The architecture is preserved, with some modifications
to exploit the convenient class library from CLR.
The porting mostly consists of restructuring to accomodate
the .NET Framefork class archtecture.
The algorithmic base(calculations) is strictly preserved.
1. All assemblies are sigle file assembly(.EXE or .DLL),
- no need of multifile or satelite assemblies because the
application speaks only English and the resources are embedded.
2. All assemblies are private, no shared or strong named assemblies.
3. Localization not implemented, the application culture is
neutral(default English).
4. Client(and Communication module), Engine and the Tracer run in
separate domains, one domain per process, hosted by Windows
Shell(the Client and the Tracer) and by SCM(the Engine).
5. The RPC communication is replaced with .NET remoting
Channels are TCP/IP and Binary Serialization Formatters are used.
Activation model is Server activated objects - Singleton main object.
Marshal-by-reference communications, the main engine sigleton object
is derived from System.MarshalByRefObject.
Lifetime leases set in the configuration file.
6. Configuration settings
Main application settings are enforsed through configuration files.
(XML *.exe.config files)
User settings are enforsed through registry keys
Microsoft.Win32.RegistryKey is used for key/values retrieval.
7. Service
The service class of the engine is derived from
System.ServiceProcess.ServiceBase and the virtual
methods are overriden.
8. Custom installers
To install the service through the InstallUtil,
a custom installer is derived from
System.ServiceProcess.ServiceProcessInstaller and
System.ServiceProcess.ServiceInstaller
9. Asynchronous communication
The Communication module invokes the calls to the Engine with
the delegate's synchronization wrappers.
BeginInvoke,EndInvoke,AsyncCallback Delegate and IAsyncResult
are used.
The Communication module sends back to the client the notifications
from the Engine through delegates.
Events are employed by the Engine objects to mark non important
changes(for example tracing/debug information)
10.Thread/Synchronization
CLR thread pool mechanisms are used through System.Threading.ThreadPool
11.Event logging
System.Diagnostics.EventLog is used.
12.Debug/Trace
Trace switches and trace listeners are employed -
System.Diagnostics.TraceSwitch and
System.Diagnostics.TextWriterTraceListener.
14.ADO .NET
Connection pooling(per thread/transaction context) enforced.
DataReaders to retrieve a read-only, forward-only streams
and ExecuteNonQuery and Stored procedures are used mainly
for fast data access.