Final Version

Análisis y Diseño/Diagrama de clases

@@ -0,0 +1 @@
+<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.96 Safari/537.36" version="6.5.7" editor="www.draw.io" type="github"><diagram name="Page-1">7VxbT+M6EP41fV3l1qY80sKeXYlFiHJuj6ZxE+86ceW4lO6vP+PEuTVxKadJWGmNEKqnji/zfeMZT2wm7jJ+/YOjbfSNBZhOHCt4nbg3E8eZ+w78lYJDLvCmfi4IOQlykV0JVuQnVkJLSXckwGmjomCMCrJtCtcsSfBaNGSIc7ZvVtsw2ux1i0LcEqzWiLalf5NARGpazqySf8EkjIqe7dlV/s0zWv8IOdslqr+J426yn/zrGBVtqYmmEQrYviZybyfukjMm8k/x6xJTqdpCbflznzXfluPmOBHnPKBwekF0p6a+uAcw1eDEoVBIuicxRQmUFpGIKQht+LhhiVipShaU1xGhwR06sJ3sPBWgjKK0iBgnP6E+Kh6Gr7lQ0INioTVC6ZJRxkGQsLyv8qGVbEx1w3EKjz0Uk7RL0R1KRTEURinapuQ5G5ysEiMekmTBhGCxqlTM6nOt5woxd6GUg7nAr1oF2yVsYA2YxVjwA1RRD0wthfShoIpqYl/xyvZUnajBKSVEisth2XbZ3SNwHyUhTLHsz502+yuKte78jt4KZhedISowT5DAC8nltM4h+FCbaCXKmNXNMrfFsokDyrVucMgxSK5lXdDnMetA7aLJuFRw9gMfsaSDOIiSMIEixRvZgoSQgHlfK7FgW9nYFq1JEt5ldW68SvKoFCNF+4gIvAK5HNMeVjuQMWhvQzO7jUgQ4EQykAkk0HNpC1sGM8q0OV3AL+h8aX2aTqYwryWU7aoMv7I6F0uWwPwQyZiFgct7LPl8Hg2dbhoemvi+xbpjHtRJ1yDACbQ9DdoPUiOYG7iHh3vqjAf3VAe3Gq1Be2i0/fl4aBfuqwYkDiB2UkWYaMRCliB6W0kXWUCEA6W8GuIwQX74R8mzwr+yAKpzF9+xEAcVH6CdYBKasvU7JkHO2sjHIwdx2kXDmNmOr1UtFY9CDBLi00rmmCJBXpqtX6JCvx1zPUk3aGKunmIu2x8i5joX3rlmPXzMgnqzGl6+Gvq/TKhzpcH6+gURKjVkYp7RcB8z5inWiRbwsKrBIin7v85w5qBqg/lgmI8a+bRzJRLtbyhBIY5xh20bB96TA3fmZ+LciwO3dekKxDk65Jb9fBA4s4AbY90XWLf962QtbF3agm02KTaR2xh4j+rCdXmLNWxWDdxjwD2m9+5IU31tr91De2zrd/HY3rnYen1gO9OYMiBs7LiP9OP0tJtuv2MabtluYy2NK71fbfGaILqMEEew405NNN7bK0z7OBpvu2nH6orGrXkPgLfTpSqfhlFQS7HkMBhr78Frz94blHei34u165Kp9ztKTW5tPNA7IvPhQNdlVb+AxeeG/jVZwAY8NdCPAH1HJDcY9G47r/okNXNLTYatX5/uHMXrrttG2eny6YXzvwhmW2Pht3JBZ3W7tqQRyL8m0XaJjbtWNx1O+PQu9Hux8XYePQf/L8Rl9J42350YAoxBgC7/PhgBtMcBYeP2RGJsGPABDOhy84MxQBfhqfUfsNrFyT2KcYMJhgbD08C2vPF44OnigMIVaIhgloRxuOC2E3vDcUF3pKL0CoYMH0qG6YgxoteOEf8UhBJBsEnsvrEJVK1j/ZWg01tD52hrOOtI759zheS8+yrHL45mXru384569HtlxdMFqRuC5WUyuQCJw7Z9atcsOecvObmZv2dX+l7inb3g6E5/GLhHg7tjDzoY3LrDHwbu0eDu2HAOBvesBWQfl1bKwliXVorMSf3Wik7LvV9b8fwxlOgMr8XipN/HaHE+iBaP7k9Zvl8IHjCHzVP2njSrNbBurbZu3Ut1mz16nR2+rSqo1axqOXsdXAWW3uzo1ILl1HF6s743949wzUfwvwPKq16BfyWixB0+VyvQx12pu2pDn5vaCGZVXHMfTbv2J8v2mhqee7MPMrp5W/NXwygeitU/p8itoPoHIO7tfw==</diagram></mxfile>

MicroSQL/BTree/BTree.cs

@@ -8,43 +8,63 @@ public class BTree<T, TKey>
         where T : IFixedLength, IAutoFormattable
         where TKey : IComparable, IFixedLength, IAutoFormattable
     {
+        // Raíz del árbol
         int Root;
+        // Posición disponible en disco para escritura
         int AvailablePointer;
-
+        // FileStream para leer y/o escribir el archivo
         FileStream FileStream;
+        // Ruta del archivo
         string FilePath;
+        // Fábrica de contenido
         IFixedLengthFactory<T> ContentFactory;
+        // Fábrica de Llaves
         IFixedLengthFactory<TKey> KeyFactory;
+        // Orden del árbol
         public int Degree { get; set; }
 
-
+        /// <summary>
+        /// Lista de elementos ordenados de forma ascendente
+        /// </summary>
+        /// <returns></returns>
         public List<T> GetElements()
         {
+            // Se crea el FileStream
             File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
             List<T> Elements = new List<T>();
-            RecorrerInOrdenRecursivo(Root, Elements);
+            InOrder(Root, Elements);
+            // Se liberan los recursos
             File.Dispose();
             return Elements;
         }
-
-        private void RecorrerInOrdenRecursivo(int posicionActual, List<T> Elements)
+        /// <summary>
+        /// Realiza recorrido en orden llenando una lista a su paso
+        /// </summary>
+        /// <param name="posicionActual"> Posición en la que se encuentra </param>
+        /// <param name="Elements"> Lista de elementos que se llena durante 
+        /// la revursión </param>
+        private void InOrder(int posicionActual, List<T> Elements)
         {
+            // Caso base de la inducción
             if (posicionActual == SizesNSpecialCharacters.NullPointer)
             {
                 return;
             }
+            // Se carga el nodo en el que se encuentra
             BNode<T, TKey> nodoActual = BNode<T, TKey>.DiskRead(File, Degree, posicionActual, ContentFactory, KeyFactory);
             for (int i = 0; i < nodoActual.ChildrenPointers.Count; i++)
             {
-                RecorrerInOrdenRecursivo(nodoActual.ChildrenPointers[i], Elements);
+                // Para cada hijo, se procede recursivamente
+                InOrder(nodoActual.ChildrenPointers[i], Elements);
                 if ((i < nodoActual.Keys.Count) && (nodoActual.Keys[i].CompareTo(KeyFactory.CreateNull()) != 0))
                 {
+                    // Visita nuevo espacio
                     Elements.Add(nodoActual.Values[i]);
                 }
             }
         }
 
-
+        #region Encapsulamiento
         public int RootPointer
         {
             get
@@ -117,113 +137,156 @@ public IFixedLengthFactory<TKey> TKeyFactory
                 KeyFactory = value;
             }
         }
+        #endregion
+
+        /// <summary>
+        ///  Actualización del encabezado
+        /// </summary>
         private void UpdateHeader()
         {
+            // Se escriben las tres líneas que contiene el encabezado
             FileManagment.WriteLine(File, 0, RootPointer);
             FileManagment.WriteLine(File, 1, FirstAvailablePointer);
             FileManagment.WriteLine(File, 2, Degree);
-            File.Flush(); // Actualizar achivo
+            // Se liberan los recursos
+            File.Flush();
         }
+        /// <summary>
+        /// Insersión recursiva d un elemento en base a su llave
+        /// </summary>
+        /// <param name="CrawlerPointer"> Posición actual en la recursión</param>
+        /// <param name="Key"> Llave</param>
+        /// <param name="Value">Valor</param>
         private void Insert(int CrawlerPointer, TKey Key, T Value)
         {
+            // Nodo actual
             BNode<T, TKey> Crawler = BNode<T, TKey>.DiskRead(File, Degree, CrawlerPointer, TFactory, TKeyFactory);
+            // En caso de que se encuentre en hoja
             if (Crawler.Leaf)
             {
+                // Se sube y actualiza el encabezado
                 MoveUp(Crawler, Key, Value, int.MinValue);
                 UpdateHeader();
             }
             else
             {
+                // Se inserta recursivamente en el nodo hijo que debería contener la clave
                 Insert(Crawler.ChildrenPointers[Crawler.FirstPointerOfNodeContaining(Key)], Key, Value);
             }
         }
         private void MoveUp(BNode<T, TKey> Crawler, TKey Key, T Value, int RightSibling)
         {
+            // Si aún hay espacio, se añade
             if (!Crawler.Full)
             {
                 Crawler.Insert(Key, Value, RightSibling);
-                Crawler.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
+                Crawler.DiskWrite(File);
+                // se interrumple el flujo
                 return;
             }
-            BNode<T, TKey> Sibling = new BNode<T, TKey>(Degree, FirstAvailablePointer, Crawler.Parent, TFactory, TKeyFactory);
-            FirstAvailablePointer++;
+            // Se crea un nuevo hermano y se prepara para subir los datos al padre
+            BNode<T, TKey> Sibling = new BNode<T, TKey>(Degree, FirstAvailablePointer++, Crawler.Parent, TFactory, TKeyFactory);
             TKey UpwardMovingKey = TKeyFactory.CreateNull();
             T UpwardMovingValue = TFactory.CreateNull();
+
+            // Se separa el nodo en dos
             Crawler.Split(Key, Value, RightSibling, Sibling, ref UpwardMovingKey, ref UpwardMovingValue);
             BNode<T, TKey> Child = null;
+            // Se cambia el apuntador en  todos los hijos
             for (int i = 0; i < Sibling.ChildrenPointers.Count; i++)
             {
                 if (Sibling.ChildrenPointers[i] != int.MinValue)
                 {
                     Child = BNode<T, TKey>.DiskRead(File, Degree, Sibling.ChildrenPointers[i], TFactory, TKeyFactory);
                     Child.Parent = Sibling.Pointer;
-                    Child.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
+                    Child.DiskWrite(File);
                 }
                 else
                 {
                     break;
                 }
             }
+            // Se evalúa el caso del caso Padre
             if (Crawler.Parent == int.MinValue)
             {
+                // En caso de que la raíz del padre sea nula,
+                // Se debe asignar una nueva raíz.
                 BNode<T, TKey> NewRoot = new BNode<T, TKey>(Degree, FirstAvailablePointer, int.MinValue, TFactory, TKeyFactory);
                 FirstAvailablePointer++;
+
+                // Se actualiza la información de la nueva raíz
                 NewRoot.ChildrenPointers[0] = Crawler.Pointer;
                 NewRoot.Insert(UpwardMovingKey, UpwardMovingValue, Sibling.Pointer);
+
+                // Se actualizan los apuntadores del padre
                 Crawler.Parent = NewRoot.Pointer;
                 Sibling.Parent = NewRoot.Pointer;
+
                 RootPointer = NewRoot.Pointer;
-                NewRoot.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
-                Crawler.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
-                Sibling.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
+                // Se guardan los cambios
+                NewRoot.DiskWrite(File);
+                Crawler.DiskWrite(File);
+                Sibling.DiskWrite(File);
             }
             else
             {
+                // No se modificó la raíz
+                Crawler.DiskWrite(File);
+                Sibling.DiskWrite(File);
 
-                Crawler.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
-                Sibling.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
-
+                // Se carga el nuevo nodo padre
                 BNode<T, TKey> Parent = BNode<T, TKey>.DiskRead(File, Degree, Crawler.Parent, TFactory, TKeyFactory);
                 MoveUp(Parent, UpwardMovingKey, UpwardMovingValue, Sibling.Pointer);
             }
         }
 
-
+        /// <summary>
+        /// Búsqueda recursiva en subárboles
+        /// </summary>
+        /// <param name="CrawlerPointer"> P</param>
+        /// <param name="Key"></param>
+        /// <param name="Pointer"></param>
+        /// <returns></returns>
         private BNode<T, TKey> BTreeSearch(int CrawlerPointer, TKey Key, out int Pointer)
         {
             BNode<T, TKey> Crawler = BNode<T, TKey>.DiskRead(File, Degree, CrawlerPointer, TFactory, TKeyFactory);
             Pointer = Crawler.PrecisePointer(Key);
             if (Pointer != -1)
-            {
                 return Crawler;
-            }
             else
-            {
                 if (Crawler.Leaf)
-                {
                     return null;
-                }
                 else
                 {
                     int FirstPointerOfNodeContaining = Crawler.FirstPointerOfNodeContaining(Key);
                     return BTreeSearch(Crawler.ChildrenPointers[FirstPointerOfNodeContaining], Key, out Pointer);
                 }
-            }
         }
+        /// <summary>
+        /// Constructor de la clase
+        /// </summary>
+        /// <param name="Degree"></param>
+        /// <param name="FilePath"></param>
+        /// <param name="ContentFactory"></param>
+        /// <param name="KeyFactory"></param>
         public BTree(int Degree, string FilePath, IFixedLengthFactory<T> ContentFactory, IFixedLengthFactory<TKey> KeyFactory)
         {
+            // Se crea el nuevo árbol con los parámetros recibidos
             FileName = FilePath;
             TFactory = ContentFactory;
             TKeyFactory = KeyFactory;
 
-            // EL problema está aquí...
+            // Se abre el FileStream para poder modificar el archivo
             File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite,
             FileShare.Read);
 
-
+            // Se realiza la lectura del archivo para obtener los datos del encabezado
             RootPointer = FileManagment.ReadLine(File, 0);
             FirstAvailablePointer = FileManagment.ReadLine(File, 1);
             this.Degree = FileManagment.ReadLine(File, 2);
+
+            // En caso de que no haya encontrado ningún dato
+            // Se inicializan los datos por que no existían antes
             if (FirstAvailablePointer == int.MinValue)
             {
                 FirstAvailablePointer = 0;
@@ -235,23 +298,36 @@ public BTree(int Degree, string FilePath, IFixedLengthFactory<T> ContentFactory,
             }
             if (RootPointer == int.MinValue)
             {
+                // Se crea la raíz
                 BNode<T, TKey> Root = new BNode<T, TKey>(this.Degree, FirstAvailablePointer, int.MinValue,
                TFactory, TKeyFactory);
                 FirstAvailablePointer++;
                 RootPointer = Root.Pointer;
-                Root.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
+                Root.DiskWrite(File);
             }
+            // Se actualiza el encabezado
             UpdateHeader();
-
+            // Se Liberan los recursos
             File.Dispose();
         }
+        /// <summary>
+        /// Inserta un elemento con llave Key
+        /// </summary>
+        /// <param name="Key"></param>
+        /// <param name="dato"></param>
         public void Insert(TKey Key, T dato)
         {
             File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite,
                        FileShare.Read);
+            // Inserta el elemento recursivamente
             Insert(RootPointer, Key, dato);
             File.Dispose();
         }
+        /// <summary>
+        /// Devuelve el valor con llave Key en caso de que exista
+        /// </summary>
+        /// <param name="Key"></param>
+        /// <returns></returns>
         public T GetValue(TKey Key)
         {
             File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
@@ -260,33 +336,49 @@ public T GetValue(TKey Key)
             File.Dispose();
             return ReachedNode.Values[Pointer];
         }
+        /// <summary>
+        /// Devuelve verdadero en caso de encontrar la llave, en caso contrario, falso.
+        /// </summary>
+        /// <param name="Key">Llave</param>
+        /// <returns></returns>
         public bool BTreeSearch(TKey Key)
         {
+            // FileStream para poder leer y escribir el archivo
             File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
             int posicion = -1;
+            // Se intenta buscar el nodo
             BNode<T, TKey> nodoObtenido = BTreeSearch(RootPointer, Key, out posicion);
             File.Dispose();
+            // Si no se encontró nodo, no existe el nodo
             if (nodoObtenido == null)
             {
                 return false;
             }
             else
             {
                 return true;
-            }
-
+            }            
         }
+        /// <summary>
+        /// Método de eliminar
+        /// </summary>
+        /// <param name="Key"> Llave por eliminar </param>
         public void Delete(TKey Key)
         {
+            // FileStream para poder leer y escribir
             FileStream File = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
+            // Se obtiene la raíz
             BNode<T, TKey> Root = BNode<T, TKey>.DiskRead(File, Degree, RootPointer, TFactory, TKeyFactory);
+            // Comienza el proceso de eliminación recursiva
             Root.Delete(File, Key);
 
-            if (!Root.Leaf && Root.N == 0)
+            if (!Root.Leaf && Root.AmountOfData == 0)
             {
                 Root = BNode<T, TKey>.DiskRead(File, Degree, Root.ChildrenPointers[0], TFactory, TKeyFactory);
             }
-            Root.DiskWrite(File, SizesNSpecialCharacters.HeaderSizeInBytes);
+            // Se escribe el archivo
+            Root.DiskWrite(File);
+            // Se liberan los recursos
             File.Dispose();
         }
     }

MicroSQL/BTree/BTree.csproj

@@ -40,8 +40,11 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BinaryTree.cs" />
+    <Compile Include="BinaryTreeNode.cs" />
     <Compile Include="BNode.cs" />
     <Compile Include="BTree.cs" />
+    <Compile Include="Comparable.cs" />
     <Compile Include="FileManagment.cs" />
     <Compile Include="IAutoFormattable.cs" />
     <Compile Include="IFixedLength.cs" />