Construir mi propio ORM

GPS plataforma, la construcción del sitio, desarrollo de software, operación y mantenimiento del sistema, para encontrar una gran tecnología de red bosque!
http://cnsendnet.taobao.com
de Sen Ciencia y Tecnología blog oficial
http://www.cnsendblog.com/index.php/?p=495

 

Mediante la descripción de los dos capítulos anteriores, creo que muchos de mis amigos tienen que entender mi siguiente para examinar la aplicación del método para el ORM, y que se basa en un atributo personalizado para definir O / R Mapping Rules, y después de adquirir dinámicamente esta regla a través de la reflexión, dinámicamente construida sentencias SQL.
Debido a que esta pequeña cosa (ORM) nació en Shenzhen, así que estoy todavía, deberá recibir el nombre de Shenzhen, así que la llamé "MiniORM". No sé qué te parece?
MiniORM utiliza ONE_INHERIT_TREE_ONE_CLASS (un árbol de herencia corresponde a una tabla) estructura, aunque esta estructura nos llevan fácilmente a la redundancia de datos, pero esta estructura es muy simple. Además, una mesa teniendo en cuenta sólo el presente MiniORM una PK, FK una situación.

MiniORM siguiente estructura, para que sea más fácil de entender y utilizar, utilizo tres categorías:
. 1, OrmWriter: Objeto de entidad responsable (como la sección anterior, dicha persona) se inserta en la base de datos y las correspondientes modificaciones de registro de base de datos.
2, OrmRemover: De acuerdo con la entidad responsable del objeto, elimine los registros especificados;
3, OrmReader: De acuerdo con la entidad responsable del objeto, leer los registros especificados;

Por encima son los tres principales clases de MiniORM. A continuación te detallamos en la descripción anterior, paso a paso la construcción de ella. Nosotros aquí o en frente de esa persona ejemplo.

El primer capítulo de esta serie, sabemos que no hay sólo una herencia de objetos, en particular, existen aplicaciones prácticas incluyen la relación, tales como Persona contiene dos clases de mano (mano) que contiene una cabeza (cabeza), etc., nuestra Persona en la base de datos debe tener un ID, para un uso más conveniente y la discusión, esta ID es un int y el tipo de crecimiento automático (IDENTIDAD ID (1,1)) en MiniORM en. Estos son el rango de nuestra MiniORM debe tener en cuenta.
Hicimos cambios en nuestra persona:

1. [DataObjectAttribute ( "Persona")]
2. Public class Persona
3. {
4. _ID int privado;
5. _NAME cadena privada;
6. _Age int privado;
7. _Sex cadena privada;
8. _Head cabeza privada;
9. _LeftHand Mano privado;
10. _RightHand Mano privado;
11.  
12. public int ID
13. {
14. obtener _ID {return; }
15. conjunto {valor _ID =; }
16. }
17.  
18. Cabeza Cabeza pública
19. {
20. obtener _head {return; }
21. conjunto {_head = valor; }
22. }
23.  
24. pública mano LeftHand
25. {
26. obtener _LeftHand {return; }
27. conjunto {_LeftHand = valor; }
28. }
29.  
30. pública de la mano derecha
31. {
32. obtener _RightHand {return; }
33. conjunto {_RightHand = valor; }
34. }
35.  
36. [DataFieldAttribute ( "nombre", "nvarchar")]
37. Nombre cadena pública
38. {
39. obtener this._Name {return; }
40. conjunto {valor this._Name =; }
41. }
42.  
43. [DataFieldAttribute ( "edad", "int")]
44. public int Edad
45. {
46. obtener this._Age {return; }
47. conjunto {valor this._Age =; }
48. }
49.  
50. [DataFieldAttribute ( "sexo", "nvarchar")]
51. public string Sexo
52. {
53. {this._Sex obtener retorno; }
54. conjunto {valor this._Sex =; }
55. }
56. }

Usted también puede encontrar que un problema es en la persona de nuestro revisada, el aumento de la LeftHand, derecha y la cabeza, pero estos tres pertenecen a la clase ah, cómo esto se puede guardar en la base de datos hace? Y el uso de nuestra DataFieldAttribute anterior hay manera de describir ah. También agrega una identificación, y cómo marcar este crecimiento automática de PK INT escribirla? Por supuesto, aquí usted será capaz de encontrar estos problemas, es bastante bueno. Si lo va a hacer frente a la gente, se estima consideración es modificar nuestra DataFieldAttribute posible distinguir estas cosas. Por ejemplo, en la DataFieldAttribute añadir una propiedad que es un ID para atributo distintivo, que es el tipo de objeto (por ejemplo, de mano) propiedades. Esto por supuesto es bueno, pero hacerlo lleva a nuestro código muy feo. La mejor forma es añadir un atributo adicional. Por supuesto, yo iba a ser más conveniente construir las sentencias SQL, no lo sé muy bien.

1, PK indican cómo la clase entidad tabla de base de datos correspondiente y el FK?
Para que sea más fácil de lograr, bandera MiniORM de una clase de entidad de PK y FK se hacen en DataObjectAttribute en (de hecho, la mejor solución es un adicional de un tal PKAttribute y FKAttribute, pero esto se deja a otros a hacerlo). A continuación, DataObjectAttribute primera parámetro de tabla de base de datos correspondiente, representado por la segunda PK parámetro, el tercer parámetro representa FK:

1. [DataObjectAttribute ( "Persona", "ID", "")]
2. Public class Persona
3. {
4. ......
5. }

2, cómo el campo de la bandera es Identity (crecimiento automático)?
El aumento de atributos en DataFieldAttribute, el campo de una marca de campo si el crecimiento automático. Estos son mi personal perezosos para hacer, que es la segunda bandera parámetro de tipo ID Identidad

1. [DataFieldAttribute ( "ID", true)]
2. public int ID
3. {
4. obtener _ID {return; }
5. conjunto {valor _ID =; }
6. }

3, cómo marcar el campo es un objeto de la clase (como persona en la mano, por supuesto, objetos más complejos, que pueden incluir una lista de sub-objetos)?
Debido MiniORM ofrece algo de un marco similar, por lo que no debería estar limitada por la clase de entidad, por lo que el campo de objeto de clase, debemos ser capaces de describir el montaje de este objeto se encuentra, espacio de nombres, nombre de la clase, creado de manera que podemos correr el objeto.

1. SubDataObjectAttribute clase pública: Atributo
2. {
3. _FieldType SubDataObjectFieldType privado;
4. _AssemblyName cadena privada;
5. _NamespaceName cadena privada;
6. _ClassName cadena privada;
7.  
8. SubDataObjectAttribute pública (FieldType SubDataObjectFieldType, assemblyname cadena, NameSpaceName cadena, cadena de nombre de clase)
9. {
10. this._FieldType = FieldType;
11. this._AssemblyName = AssemblyName;
12. this._NamespaceName = NameSpaceName;
13. this._ClassName = nombre de clase;
14. }
15.  
16. /// <summary>
17. /// Este registro correspondiente FieldType
18. /// </ summary>
19. pública SubDataObjectFieldType FieldType
20. {
21. obtener _FieldType {return; }
22. }
23.  
24. /// <summary>
25. /// Este registro correspondiente AssemblyName
26. /// </ summary>
27. AssemblyName cadena pública
28. {
29. obtener _AssemblyName {return; }
30. }
31.  
32. /// <summary>
33. /// Este registro correspondiente NameSpaceName
34. /// </ summary>
35. NameSpaceName cadena pública
36. {
37. obtener _NamespaceName {return; }
38. }
39.  
40. /// <summary>
41. /// Este registro correspondiente NombredeClase
42. /// </ summary>
43. NombredeClase cadena pública
44. {
45. obtener _className {return; }
46. }
47. }

SubDataObjectFieldType que es un tipo enumerado, porque nuestra sub-objeto puede ser un objeto separado tal como Person.Head también puede ser una lista (LIST). Por lo que añade este tipo de enumeración, que se utiliza para hacer señales.

1. SubDataObjectFieldType enumeración pública
2. {
3. Objeto,
4. /// <summary>
5. Lista de tipos de /// Este campo pertenece, para atravesar directamente
6. /// </ summary>
7. Lista,
8. }

Por supuesto, he aquí una lista de sub-objetos pueden ser ArrayList, HashTable, etc., puede hacer los cambios apropiados en función de su uso real al tipo de proyecto.

4, la forma de controlar un campo no se puede repetir en la tabla?
Por ejemplo, tenemos que controlar Person.Name no se puede repetir, si se agrega el tiempo para encontrar consejos duplicados. Entonces también lograrse mediante la adición de una representación de atributo. Atributo esto es muy simple, no hay métodos y propiedades.

1. DataFieldNotDoubleAttribute clase pública: Atributo
2. {
3. }

5, la forma de hacer la transacción?
Cada transacción es el marco subyacente debería tener en cuenta los problemas en .NET que tenemos dos formas de procesamiento de transacciones mango, es el uso de COM +, este es el mejor método, pero el rendimiento es bastante deficiente, la otra cosa que Configuración de un montón de problemas cuando la base de datos está instalado en otro también servidores, a menudo problemas no se pueden utilizar, yo solía ser esta cosa es bastante frustrante para ahogar, así que simplemente no lo tengo, pero presentaron a la gramática, mediante el uso de TransactionScope puede ser un uso bien com + transacciones previstas por el código es simple bastante, hermoso, pero, por desgracia, ¡ah! cara de ángel, corazón del diablo.

1. function1 public void ()
2. {
3. usando (alcance System.Transactions.TransactionScope = new System.Transactions.TransactionScope (System.Transactions.TransactionScopeOption.Required))
4. {
5. function2 ();
6. }
7. }
8.  
9. function2 public void ()
10. {
11. usando (alcance System.Transactions.TransactionScope = new System.Transactions.TransactionScope (System.Transactions.TransactionScopeOption.Required))
12. {
13. //Hacer algo();
14. }
15. }

Otro método es el uso SqlTransaction:

1. usando (SqlConnection conn = new SqlConnection (ConnectionStr))
2. {
3. conn.Open ();
4. SqlTransaction trans = conn.BeginTransaction ();
5. //Hacer algo();
6. trans.Commit ();
7. }

Pero por desgracia no se puede lograr en este anidamiento de transacción manera, por lo que la transacción sólo puede lograrse a través de la trans pasa como argumento.

Después de una serie de modificaciones anteriores, nuestra persona se convirtió en lo que era?

1. [DataObjectAttribute ( "Persona", "ID", "")]
2. Public class Persona
3. {
4. _ID int privado;
5. _NAME cadena privada;
6. _Age int privado;
7. _Sex cadena privada;
8. _Head cabeza privada;
9. _LeftHand Mano privado;
10. _RightHand Mano privado;
11.  
12. [DataFieldAttribute ( "ID", true)]
13. public int ID
14. {
15. obtener _ID {return; }
16. conjunto {valor _ID =; }
17. }
18.  
19. [SubDataObjectAttribute (SubDataObjectFieldType.Object, "Persona", "Persona", "Cabeza")]
20. Cabeza Cabeza pública
21. {
22. obtener _head {return; }
23. conjunto {_head = valor; }
24. }
25.  
26. [SubDataObjectAttribute (SubDataObjectFieldType.Object, "Persona", "Persona", "mano")]
27. pública mano LeftHand
28. {
29. obtener _LeftHand {return; }
30. conjunto {_LeftHand = valor; }
31. }
32.  
33. [SubDataObjectAttribute (SubDataObjectFieldType.Object, "Persona", "Persona", "mano")]
34. pública de la mano derecha
35. {
36. obtener _RightHand {return; }
37. conjunto {_RightHand = valor; }
38. }
39.  
40. [DataFieldAttribute ( "nombre", "nvarchar")]
41. Nombre cadena pública
42. {
43. obtener this._Name {return; }
44. conjunto {valor this._Name =; }
45. }
46.  
47. [DataFieldAttribute ( "edad", "int")]
48. public int Edad
49. {
50. obtener this._Age {return; }
51. conjunto {valor this._Age =; }
52. }
53.  
54. [DataFieldAttribute ( "sexo", "nvarchar")]
55. public string Sexo
56. {
57. {this._Sex obtener retorno; }
58. conjunto {valor this._Sex =; }
59. }
60. }
61.  
62.  

Por supuesto, para una entidad tal clase Person, podemos escribir sus propias herramientas de generación de código para entrar, y luego hacer pequeñas modificaciones en él, esta herramienta es simple, no voy a discutir.
Bueno, en mi MiniORM he discutido aquí, otros ven el código.

Aunque el ORM es una cosa buena, pero también son inadecuados en muchos aspectos, en primer lugar lo que podemos hacer es pagar la mayoría de las operaciones de base de datos ORM hacer. Además de una pequeña parte de nuestra propia todavía tienen que escribir el código SQL. La mayoría del trabajo individual por separado nosotros puede ahorrar mucho tiempo (también conocido como el principio 20/80, 80% de ORM enseñado a manejar el 20% de su cuenta, por supuesto, muy bueno). Además de procesar por estos mismos procesos ORM enseñado, puede evitar muchos de los errores causados por negligencia (como accidentalmente puso inserción, actualización, instrucción de eliminación cometido un error o algo así).
El principal inconveniente, por supuesto, es un problema de rendimiento, especialmente a mi MiniORM, todo ello utilizando la reflexión para obtener las reglas de asignación, lo que más caída en el rendimiento, pero después de entender el método es muy fácil de pasar el código generado de forma dinámica, forma compilación dinámica la reducción de la pérdida de rendimiento de esta parte. Una parte adicional del código algo engorroso, en particular para determinar si dicho código una descarga Indentity DataFieldAttribute con el proceso (como este tipo pueden DataFieldNotDoubleAttribute un proceso separado) y similares.

 

GPS plataforma, la construcción del sitio, desarrollo de software, operación y mantenimiento del sistema, para encontrar una gran tecnología de red bosque!
http://cnsendnet.taobao.com
de Sen Ciencia y Tecnología blog oficial
http://www.cnsendblog.com/index.php/?p=495