Construct my own ORM

GPS platform, site construction, software development, system operation and maintenance, to find a large forest network technology!
http://cnsendnet.taobao.com
from Sen Science and Technology official blog
http://www.cnsendblog.com/index.php/?p=495

By describing the previous two chapters, I believe many of my friends have to understand my following to discuss the implementation of the method to the ORM, and that is based on a custom Attribute to define O / R Mapping Rules, and then dynamically acquire this rule through reflection, dynamically constructed SQL statements.
Because this little thing (ORM) was born in Shenzhen, so I am still, she should have the name of Shenzhen, so I called her "MiniORM". I do not know how you think?
MiniORM uses ONE_INHERIT_TREE_ONE_CLASS (an inheritance tree corresponds to a table) structure, though this structure easily lead to data redundancy, but this structure is very simple. Also, a table considering only the present MiniORM a PK, FK a situation.

MiniORM following structure, to make it easier to understand and use, I use three categories:
. 1, OrmWriter: responsible entity object (such as the previous section, said Person) inserted into the database and the corresponding database record modifications.
2, OrmRemover: According to the entity responsible for the object, delete the specified records;
3, OrmReader: According to the entity responsible for the object, read the specified records;

Above is the three main classes of MiniORM. Here we detail in the foregoing description, step by step construction of her. We here or in front of that Person example.

The first chapter of this series, we know that there is not only an object inheritance, in particular, there are practical applications include the relationship, such as a Person contains two Hand (hand) class that contains a Head (head), etc., our Person in the database should have an ID, for more convenient use and discussion, this ID is an int and automatic growth type (ID INDENTITY (1,1)) in MiniORM in. These are the range of our MiniORM should consider.
We made changes to our Person:

[DataObjectAttribute("Person")]
public class Person
{
private int _ID;
private string _Name;
private int _Age;
private string _Sex;
private Head _Head;
private Hand _LeftHand;
private Hand _RightHand;
public int ID
{
get { return _ID; }
set { _ID = value; }
}
public Head Head
{
get { return _Head; }
set { _Head = value; }
}
public Hand LeftHand
{
get { return _LeftHand; }
set { _LeftHand = value; }
}
public Hand RightHand
{
get { return _RightHand; }
set { _RightHand = value; }
}
[DataFieldAttribute("name", "NvarChar")]
public string Name
{
get { return this._Name; }
set { this._Name = value; }
}
[DataFieldAttribute("age", "int")]
public int Age
{
get { return this._Age; }
set { this._Age = value; }
}
[DataFieldAttribute("sex", "NvarChar")]
public string Sex
{
get { return this._Sex; }
set { this._Sex = value; }
}
}

You may well find that a problem is in the Person our revised, increasing the LeftHand, RightHand and Head, but these three belong to class ah, how this can be saved to the database do? And using our previous DataFieldAttribute is no way to describe ah. It also adds a ID, and how to mark this automatic growth of PK int type it? Of course, here you will be able to find these problems it is quite good. If you will do it in front of people, it is estimated consideration is to modify our DataFieldAttribute it possible to distinguish these things. For example, in the DataFieldAttribute add a property which is an ID for distinguishing attribute, which is the object type (such as Hand) properties. This is of course good, but doing so leads to our code extremely ugly. The best way is to add an additional Attribute. Of course, I was to be more convenient to construct SQL statements, I do not very good.

1, PK indicate how the database table corresponding entity class and FK?
To make it easier to achieve, MiniORM flag of an entity class PK and FK are done in DataObjectAttribute in (in fact, the best solution is an additional one such PKAttribute and FKAttribute, but this is left to others to do it). Below, DataObjectAttribute first parameter corresponding database table, represented by the second parameter PK, the third parameter represents FK:

[DataObjectAttribute("Person", "ID", "")]
public class Person
{
......
}

2, how flag field is Indentity (automatic growth)?
Increased attributes in DataFieldAttribute, the field for a field mark whether the automatic growth. These are my personal lazy to do, which is the second parameter flag ID Identity type

[DataFieldAttribute("ID", true)]
public int ID
{
get { return _ID; }
set { _ID = value; }
}

3, how to mark the field is a class object (such as Person in Hand, of course, more complex objects, which may include a list of sub-objects)?
Because MiniORM provides is something of a similar framework, so it should not be limited by the entity class, so the class object field, we should be able to describe the assembly of this object is located, namespace, class name, created so that we can run the object.

public class SubDataObjectAttribute : Attribute
{
private SubDataObjectFieldType _FieldType;
private string _AssemblyName;
private string _NamespaceName;
private string _ClassName;
public SubDataObjectAttribute(SubDataObjectFieldType fieldtype, string assemblyname, string namespacename, string classname)
{
this._FieldType = fieldtype;
this._AssemblyName = assemblyname;
this._NamespaceName = namespacename;
this._ClassName = classname;
}
/// <summary>
/// This record corresponding FieldType
/// </summary>
public SubDataObjectFieldType FieldType
{
get { return _FieldType; }
}
/// <summary>
/// This record corresponding AssemblyName
/// </summary>
public string AssemblyName
{
get { return _AssemblyName; }
}
/// <summary>
/// This record corresponding NamespaceName
/// </summary>
public string NamespaceName
{
get { return _NamespaceName; }
}
/// <summary>
/// This record corresponding ClassName
/// </summary>
public string ClassName
{
get { return _ClassName; }
}
}

SubDataObjectFieldType which is an enumerated type, because our sub-object may be a separate object such as Person.Head may also be a list (List). So I added this enumeration type, used to make signs.

public enum SubDataObjectFieldType
{
Object,
/// <summary>
List Type /// This field belongs, to traverse directly
/// </summary>
List,
}

Of course, here's a list of sub-objects may be ArrayList, HashTable, etc., you can do the appropriate changes according to their actual use to project type.

4, how to control a field can not be repeated in the table?
For example, we have to control Person.Name can not be repeated, if you add the time to find duplicate tips. Then we also be achieved by adding an Attribute form. Attribute this is very simple, there is no methods and properties.

public class DataFieldNotDoubleAttribute : Attribute
{
}

5, how to do the transaction?
Each transaction is the underlying framework should take into account the problems in .NET we have two ways to handle transaction processing, is to use COM +, this is the best method, but the performance is quite lacking, the other thing that Configuring a lot of trouble when you database is installed on another too servers, often problems can not be used, I used to be this thing is frustrating enough to choke, so I just do not have him, but was introduced to grammar, by using TransactionScope can be a good use com + transactions provided by the code is quite simple, beautiful, but unfortunately ah! Angel face, devil's heart.

public void function1()
{
using (System.Transactions.TransactionScope scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required))
{
function2 ();
}
}
public void function2()
{
using (System.Transactions.TransactionScope scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required))
{
//DoSomething();
}
}

Another method is to use SqlTransaction:

using (SqlConnection conn = new SqlConnection(ConnectionStr))
{
conn.Open();
SqlTransaction trans = conn.BeginTransaction();
//DoSomething();
trans.Commit();
}

But unfortunately it can not be achieved in this way transaction nesting, so the transaction can only be achieved through the trans passed as an argument.

After a series of modifications above, our Person became what it was like?

[DataObjectAttribute("Person", "ID", "")]
public class Person
{
private int _ID;
private string _Name;
private int _Age;
private string _Sex;
private Head _Head;
private Hand _LeftHand;
private Hand _RightHand;
[DataFieldAttribute("ID", true)]
public int ID
{
get { return _ID; }
set { _ID = value; }
}
[SubDataObjectAttribute(SubDataObjectFieldType.Object, "Person", "Person", "Head")]
public Head Head
{
get { return _Head; }
set { _Head = value; }
}
[SubDataObjectAttribute(SubDataObjectFieldType.Object, "Person", "Person", "Hand")]
public Hand LeftHand
{
get { return _LeftHand; }
set { _LeftHand = value; }
}
[SubDataObjectAttribute(SubDataObjectFieldType.Object, "Person", "Person", "Hand")]
public Hand RightHand
{
get { return _RightHand; }
set { _RightHand = value; }
}
[DataFieldAttribute("name", "NvarChar")]
public string Name
{
get { return this._Name; }
set { this._Name = value; }
}
[DataFieldAttribute("age", "int")]
public int Age
{
get { return this._Age; }
set { this._Age = value; }
}
[DataFieldAttribute("sex", "NvarChar")]
public string Sex
{
get { return this._Sex; }
set { this._Sex = value; }
}
}

Of course, for such an entity class Person, we can write their own code generation tools to get, and then do minor modifications on it, this tool is simple, I will not discuss.
Well, on my MiniORM I discussed here, others see the code.

Although the ORM is a good thing, but there are also inadequate in many ways, first of all we can do is to pay a majority of database operations ORM do. In addition a small part of our own still need to write the SQL. Most of the separate single work can save us a lot of time (also known as the 20/80 principle, 80% of taught ORM to handle 20% of their own, of course, very good). In addition to processing by these same processes taught ORM, can avoid a lot of mistakes caused by negligence (such as accidentally put an Insert, Update, Delete statement made a mistake or something).
The main drawback of course is a performance problem, especially my MiniORM, all using reflection to get the mapping rules, leading to more drop in performance, but after we understand the method is very easy to pass dynamically generated code, dynamic compilation way reducing the performance loss of this part. Some additional part of the code somewhat cumbersome, particularly to determining whether such a code Indentity discharge DataFieldAttribute to process (as this kind can DataFieldNotDoubleAttribute a separate process) and the like.

Construct my own ORM

Guess you like