14,696,499 members
Articles » Development Lifecycle » Design and Architecture » Design and Strategy
Article
Posted 8 May 2012

25.5K views
32 bookmarked

# The Time Machine

Rate me:
9 May 2012CPOL
Long time strategy of software design and development

## 1. Introduction

Math contains levels of theories. First level arithmetic contains theorems about integers. Second level theorems (metatheorems) are theorems about first level theorems. The third arithmetic, fourth one, etc. The duality theorem concerns to theorems and therefore it is metatheorem. In this chapter, metadriver is discussed. Following code can be regarded as metadriver. This code is looking for singletons of objects which implement one interface:

```/// <summary>
/// Gets interfaces from assembly (Searching of driver assembly)
/// </summary>
/// <typeparam name="T">Interface type</typeparam>
/// <param name="assembly">Assembly</param>
/// <returns>Interface objects</returns>
public static IEnumerable<T> GetInterfaces<T>(this Assembly assembly) where T : class
{
Type[] types = assembly.GetTypes(); // Assembly types
string st = typeof(T).FullName;     // Interface full name
foreach (Type t in types)
{
Type ti = t.GetInterface(st);   // Gets interface
if (ti == null)
{
continue;
}
FieldInfo fi = t.GetField("Singleton"); // Gets Singleton field
if (fi != null)
{
yield return fi.GetValue(null) as T; // yeild Singleton
}
}
}
```

Following code snippet contains search of singletons in a set of assemblies:

```/// <summary>
/// Gets interfaces
/// </summary>
/// <typeparam name="T">Interface type</typeparam>
/// <param name="directory">Directory</param>
/// <returns>Interface objects</returns>
public static IEnumerable<T> GetInterfaces<T>(this string directory) where T : class
{
string[] fn = Directory.GetFiles(directory, "*.dll");   // Dll files
Assembly[] ass = AppDomain.CurrentDomain.GetAssemblies(); // Current domain assemblies
List<string> l = new List<string>();
foreach (Assembly a in ass) // Looking for objects in loaded assemblies
{
IEnumerable<T> en = a.GetInterfaces<T>();
foreach (T t in en)
{
yield return t;
}
}
foreach (string f in fn) // Looking for objects in directory
{
if (!l.Contains(f))
{
foreach (T t in en)
{
yield return t;
}
}
}
}

/// <summary>
/// Gets interfaces from base directory
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <returns>Interfaces</returns>
public static IEnumerable<T> GetInterfacesFromBaseDirectory<T>() where T : class
{
return AppDomain.CurrentDomain.BaseDirectory.GetInterfaces<T>();
}
```

In many cases, one driver only is needed. Following code contains looking for a single driver:

```/// <summary>
/// Gets first interface object
/// </summary>
/// <typeparam name="T">Type of interface</typeparam>
/// <param name="directory">Directory</param>
/// <returns>First object</returns>
public static T GetFirstInterfaceObject<T>(this string directory) where T : class
{
IEnumerable<T> en = directory.GetInterfaces<T>();
foreach (T t in en)
{
return t;
}
return null;
}

/// <summary>
/// Gets first interface object
/// </summary>
/// <typeparam name="T">Type of interface</typeparam>
/// <returns>First object</returns>
public static T GetFirstInterfaceObjectFromBaseDirectory<T>() where T : class
{
return AppDomain.CurrentDomain.BaseDirectory.GetFirstInterfaceObject<T>();
}
```

Instruction of the above code usage is very simple. Dynamic link library file (files) should be copied to base directory of current domain.

## 3 Applications

### 3D Graphics

The following code represents common 3D Graphics interface:

```/// <summary>
/// Factory of 3D objects and cameras
/// </summary>
public interface IPositionObjectFactory
{
/// <summary>
/// Creates  3D object
/// </summary>
/// <param name="type">Object's type</param>
/// <returns>The object</returns>
object CreateObject(string type);

/// <summary>
/// Creates new camera
/// </summary>
/// <returns></returns>
Camera NewCamera();

/// <summary>
/// Creates editor of properties of camera
/// </summary>
/// <param name="camera">The camera</param>
/// <returns>The property editor</returns>
object CreateForm(Camera camera);

/// <summary>
/// Creates editor of properties of visible object
/// </summary>
/// <param name="position">Position of object</param>
/// <param name="visible">Visible object</param>
/// <returns>Editor of properties of visible object</returns>
object CreateForm(IPosition position, IVisible visible);

/// <summary>
/// Type of camera
/// </summary>
Type CameraType
{
get;
}

/// <summary>
/// Creates label on desktop
/// </summary>
/// <param name="obj">Object for label</param>
/// <returns>The label</returns>
IObjectLabel CreateLabel(object obj);

/// <summary>
/// Creates label of visible object
/// </summary>
/// <param name="position">Position of object</param>
/// <param name="visible">Visible object</param>
/// <returns>Editor of properties of visible object</returns>
object CreateLabel(IPosition position, IVisible visible);
```

OpenGL and WPF implementations of this interface are developed in the present day. The following class diagram represents these implementations:

Every implementation class contains `Singleton` field as it is presented below:

```/// <summary>
/// WPF implementation of 3D Graphics
/// </summary>
public class WpfFactory : PositionObjectFactory
{
#region Fields

/// <summary>
/// Singleton
/// </summary>
public static readonly WpfFactory Singleton =
new WpfFactory();

#endregion

#region Ctor

/// <summary>
/// Private default constructor
/// </summary>
private WpfFactory()
{
}

#endregion
```

Both these implementations are contained in different dynamic link libraries.

 N Technology Implementation class Dynamic link library file 1 `OpenGL` `OpenGLFactory` InterfaceOpenGL.dll 2 `WPF` `WpfFactory` WpfInterface.UI.dll

The following code snippet represents selection of 3D Graphics interface:

```/// <summary>
/// Global factory
/// </summary>
public static IPositionObjectFactory BaseFactory
{
get
{
if (baseFactory == null)
{
baseFactory =
AssemblyService.StaticExtensionAssemblyService.
GetFirstInterfaceObjectFromBaseDirectory<IPositionObjectFactory>();
}
return baseFactory;
}
}```

So if we would like use OpenGL technology, then InterfaceOpenGL.dll file should be copied to base directory, etc. More information about applications of 3D Graphics is contained in this article devoted to virtual reality.

### 3.2 Scientific Data

#### 3.2.1 Scientific Data Processing

Database can be a good warehouse of scientific data. Otherwise, user of software should have a good interface for data access. Let us consider sample, both data access and data processing. In this sample, we have the following two nonlinear functions f1, f2:

Parameters `a`, `b`, `c`, `d`, `g` of these functions are not known. Values of functions and variables `x`, `y`, `z` are stored in database which have the following scheme:

Parameters with "`id`" prefix are id of values of variables. Meaning of database parameters is clear. Following SQL Query provides retrieving of values of variables and functions.

```SELECT x.x, y.y, z.z, f1.f1, f2.f2 FROM f1, f2, x, y, z _
WHERE x.Id = f1.Idx AND y.Id = f1.Idy AND z.Id = f1.Idz AND f1.Idx = f2.Idx _
AND f1.Idy = f2.Idy AND f1.Idz = f2.Idz```

Now let us consider the full solution of this task. The following picture contains components of this task:

.

The Data component performs Database query. Properties of Data are presented below:

Properties of this component are clear. The SQL Server driver is used. Other properties are connection string and SQL Query. The Iterator component can be regarded as cursor. The Formula component contains definition of f1, f2. Properties of Formula are presented below:

Parameters `a`, `b`, `c`, `d`, `g` are constants of formulae. Variables `x`, `y`, `z` correspond to retrieved from database real numbers. The Processor component performs definition of above constants. Properties of Processor are presented below:

Left panel of the above picture means that we would like to define constants `a`, `b`, `c`, `d`, `g` of Formula component. Right panel means that we would like approximate retrieved from database f1, f2 by `Formula_1` and `Formula_2` of Formula. Left and right parts of the below picture contain prior and posterior values.

#### 3.2.2 Database Drivers

In the above sample, SQL Server has been used. It is clear that scientists can use Oracle for the same purpose. Software should support the following options:

Drivers should be contained in different assemblies. Low coupled software should separate Oracle driver from SQL Server one since good software should support the following options:

• Support of Oracle
• Support of SQL Server
• Support of both Oracle and SQL Server
• Do not support any database

So software should contain abstract database layer. Following code represent this abstract layer:

```/// <summary>
/// Factory for creating data set metadata from connection
/// </summary>
public interface IDataSetFactory
{
/// <summary>
/// Name of factory
/// </summary>
string FactoryName
{
get;
}

/// <summary>
/// Creates connection
/// </summary>
DbConnection Connection
{
get;
}

/// <summary>
/// Command
/// </summary>
DbCommand Command
{
get;
}

/// <summary>
/// Gets metadata data set from connection
/// </summary>
/// <param name="connection">The connection</param>
DataSet GetData(DbConnection connection);

/// <summary>
/// Gets metadata data set from connection string
/// </summary>
/// <param name="connectionString">The connection</param>
DataSet GetData(string connectionString);

/// <summary>
/// </summary>
{
get;
}

/// <summary>
/// Creates type from metadata row
/// </summary>
/// <returns>The type</returns>
Type GetTypeFromRow(DataRow row);

/// <summary>
/// </summary>
string TableName
{
get;
}

/// <summary>
/// </summary>
string ColumnName
{
get;
}

/// <summary>
/// </summary>
string IsNullable
{
get;
}

/// <summary>
/// Gets string representation of type
/// </summary>
/// <param name="type">The type</param>
/// <returns>The string representation</returns>
string GetStringFromType(Type type);

/// <summary>
/// Generates statement from desktop
/// </summary>
/// <param name="desktop">The desktop</param>
/// <returns>The statement</returns>
string GenerateStatement(IDataSetDesktop desktop);

/// <summary>
/// Gets object type
/// </summary>
/// <param name="column">Column</param>
/// <returns>The type</returns>
object GetObjectType(DataColumn column);

/// <summary>
/// Generates script
/// </summary>
/// <param name="column">Column</param>
/// <returns>Script</returns>
string GenerateScript(IColumn column);

/// <summary>
/// Generates create script
/// </summary>
/// <param name="table">Table</param>
/// <returns>Script lines</returns>
List<string> GenerateScript(ITable table);

/// <summary>
/// Generates creation script from metadata
/// </summary>
/// <returns>Creation script</returns>
}
```

List of database drivers can be extended. Now ODBC, SQL Server and Oracle drivers are already developed. The following picture represents class diagram of these drivers.

The following code represents usage of these drivers:

```/// <summary>
/// Initialization of database drivers
/// </summary>
/// <param name="path">Path of drivers</param>
void Initialize(string path)
{
// Gets all database drivers from this directory
IEnumerable<IDataSetFactory> en = path.GetInterfaces<IDataSetFactory>();
List<string> l = new List<string>();
foreach (IDataSetFactory f in en)
{
factories[f.FactoryName] = f; // Dictinary of drivers
}
List<string> ln = new List<string>(factories.Keys);
ln.Sort();
names = ln.ToArray(); // Ordered names of drivers
}
```

If Oracle driver is used instead of the SQL Server one, then properties of Data would be changed in the following way:

In the above picture, driver and connection string are changed. In some cases, change of query is required.

### 3.3 Other Samples

List of samples can be extended. However, the general idea is already clear. Other samples shall be described in future specific articles.

## Points of Interest

I do not know what is more useful, my code or inspiration of you for good work even if you are threatened with a madhouse.

## Share

 Architect Russian Federation
Ph. D. Petr Ivankov worked as scientific researcher at Russian Mission Control Centre since 1978 up to 2000. Now he is engaged by Aviation training simulators http://dinamika-avia.com/ . His additional interests are:

1) Noncommutative geometry

http://front.math.ucdavis.edu/author/P.Ivankov

2) Literary work (Russian only)

http://zhurnal.lib.ru/editors/3/3d_m/

3) Scientific articles
http://arxiv.org/find/all/1/au:+Ivankov_Petr/0/1/0/all/0/1

 First Prev Next
 My vote of 5 Kanasz Robert28-Sep-12 8:19 Kanasz Robert 28-Sep-12 8:19
 Interesting article
 My vote of 5 Mohammad A Rahman22-May-12 18:48 Mohammad A Rahman 22-May-12 18:48
 My vote of 5 Volynsky Alex21-May-12 7:38 Volynsky Alex 21-May-12 7:38
 Interesting, as always with Dr. Ivankov ZakPatat9-May-12 12:50 ZakPatat 9-May-12 12:50
 I'm not sure... ii_noname_ii9-May-12 4:49 ii_noname_ii 9-May-12 4:49
 Re: I'm not sure... Vitaly Tomilov9-May-12 8:10 Vitaly Tomilov 9-May-12 8:10
 Re: I'm not sure... Petr Ivankov9-May-12 9:13 Petr Ivankov 9-May-12 9:13
 Re: I'm not sure... bitterskittles9-May-12 23:51 bitterskittles 9-May-12 23:51
 Re: I'm not sure... ZakPatat9-May-12 13:12 ZakPatat 9-May-12 13:12
 Re: I'm not sure... Vitaly Tomilov9-May-12 16:21 Vitaly Tomilov 9-May-12 16:21
 Last Visit: 1-Dec-20 18:12     Last Update: 1-Dec-20 18:12 Refresh 1