#Update-vs1.0.1

## [1.0.1] - 15/01/2023
### Add
- `class PrintOut`
- `class TypeUtilitarian`
- `interface IReadOnlyArray`
- `interface IReadOnlyArray<T>`

Classe de leitura de arquivos com formato `.alf` adicionadado.
- `namespace Cobilas.IO.Alf`

### Obsolete
- `class CobilasConsole`
- `class CobilasTypeUtility`
### Change
- `class ALFBTWrite` > `class ALFBTWriter`

CHANGELOG.md

@@ -1,4 +1,20 @@
 # Changelog
+## [1.0.1] - 15/01/2023
+### Add
+- `class PrintOut`
+- `class TypeUtilitarian`
+- `interface IReadOnlyArray`
+- `interface IReadOnlyArray<T>`
+
+Classe de leitura de arquivos com formato `.alf` adicionadado.
+- `namespace Cobilas.IO.Alf`
+
+### Obsolete
+- `class CobilasConsole`
+- `class CobilasTypeUtility`
+### Change
+- `class ALFBTWrite` > `class ALFBTWriter`
+
 ## [1.0.0] - 11/11/2022
 ### Repositorio com.cobilas.core iniciado
 - Lançado para o GitHub

Runtime/Cobilas/CobilasConsole.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Diagnostics;
+
+namespace Cobilas {
+    [Obsolete("Use PrintOut class")]
+    public static class CobilasConsole {
+
+        /// <summary>Default separator CRLF</summary>
+        public static Action<object> Write { get => PrintOut.Write; set => PrintOut.Write = value; }
+        public static string Separator { get => PrintOut.Separator; set => PrintOut.Separator = value; }
+        public static Action<object> WriteLine { get => PrintOut.WriteLine; set => PrintOut.WriteLine = value; }
+
+        public static void Print(params object[] values) => PrintOut.Print(values);
+        public static void Print(object value) => PrintOut.Print(value);
+        public static void Print(IFormatProvider provider, string format, params object[] args) => PrintOut.Print(provider, format, args);
+        public static void Print(string format, params object[] args) => PrintOut.Print(format, args);
+
+        public static void PrintLine(object value) => PrintOut.Print(value);
+        public static void PrintLine(string format, params object[] args) => PrintOut.Print(format, args);
+        public static void PrintLine(IFormatProvider provider, string format, params object[] args) => PrintOut.Print(provider, format, args);
+
+        public static void TrackedPrint(object value) => PrintOut.TrackedPrint(value);
+        public static void TrackedPrintLine(params object[] values) => PrintOut.TrackedPrintLine(values);
+        public static void TrackedPrintLine(string format, params object[] args) => PrintOut.TrackedPrintLine(format, args);
+        public static void TrackedPrintLine(IFormatProvider provider, string format, params object[] args) => PrintOut.TrackedPrintLine(provider, format, args);
+
+        public static StackFrame[] TrackMethod() => PrintOut.TrackMethod();
+        public static string MethodTrackingList(int startIndex) => PrintOut.MethodTrackingList(startIndex);
+
+        public static void ResetSeparato() => PrintOut.ResetSeparato();
+        public static void ResetWrite() => PrintOut.ResetWrite();
+        public static void ResetWriteLine() => PrintOut.ResetWriteLine();
+    }
+}

Runtime/Cobilas/Core/CobilasTypeUtility.cs → Runtime/Cobilas/CobilasTypeUtility.cs

@@ -3,6 +3,7 @@
 using Cobilas.Collections;
 
 namespace Cobilas {
+    [Obsolete("Use TypeUtilitarian calss")]
     public static class CobilasTypeUtility {
         public static bool TypeExist(string fullName) {
             Assembly[] assemblies = GetAssemblies();

Runtime/Cobilas/Collections/ArrayManipulation.cs

@@ -4,114 +4,103 @@
 using System.Collections.ObjectModel;
 
 namespace Cobilas.Collections {
+    /// <summary>Classe de manipulação de matriz.</summary>
     public static class ArrayManipulation {
-        public static event Action<object> ExceptionEvent;
-        private static bool _autoClear;
-        private static int autoClearLength;
-        private static Queue<Exception> exceptions;
-
-        public static Exception[] ExceptionsList => exceptions.ToArray();
-        public static Exception FirstError => exceptions.Count == 0 ? (Exception)null : ExceptionsList[0];
-        public static Exception LastError => exceptions.Count == 0 ? (Exception)null : ExceptionsList[exceptions.Count - 1];
-
-        static ArrayManipulation() {
-            exceptions = new Queue<Exception>();
-            _autoClear = true;
-            autoClearLength = 5;
-            ExceptionEvent = null;
-        }
-
-        public static void AutoClearExceptionsList(bool autoClear, int length = 5) {
-            _autoClear = autoClear;
-            autoClearLength = length;
-        }
-
-        private static void AddException(Exception e) {
-            if (ExceptionEvent != null) ExceptionEvent(e);
-            if (_autoClear) {
-                if (exceptions.Count < autoClearLength) exceptions.Enqueue(e);
-                else {
-                    int length = (exceptions.Count - autoClearLength) - 1;
-                    length = length < 0 ? 0 : length;
-                    for (int I = 0; I < length; I++)
-                        _ = exceptions.Dequeue();
-                    exceptions.Enqueue(e);
-                }
-            }
-            else exceptions.Enqueue(e);
-        }
-
-        //Insert
+        /// <summary>Insira um item no idice de um <see cref="Array"/>.</summary>
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="index">Indice alvo.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Insert<T>(T[] itens, int index, T[] list) {
-            try {
-                if (list == null) list = new T[0];
-                T[] newList = new T[list.Length + itens.Length];
-                Array.Copy(list, 0, newList, 0, index);
-                Array.Copy(itens, 0, newList, index, itens.Length);
-                Array.Copy(list, index, newList, itens.Length + index, list.Length - index);
-                return newList;
-            } catch (Exception e) {
-                AddException(e);
-                return list;
-            }
-        }
-
+            if (list == null) list = new T[0];
+            T[] newList = new T[list.Length + itens.Length];
+            Array.Copy(list, 0, newList, 0, index);
+            Array.Copy(itens, 0, newList, index, itens.Length);
+            Array.Copy(list, index, newList, itens.Length + index, list.Length - index);
+            return newList;
+        }
+
+        /// <summary>Insira um item no idice de um <see cref="Array"/>.</summary>
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="index">Indice alvo.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Insert<T>(T item, int index, T[] list)
             => Insert<T>(new T[] { item }, index, list);
 
+        /// <summary>Insira um item no idice de um <see cref="Array"/>.</summary>
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="index">Indice alvo.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Insert<T>(IEnumerator<T> itens, int index, T[] list) {
-            try {
-                while (itens.MoveNext())
-                    list = Insert<T>(itens.Current, index, list);
-            } catch (Exception e) {
-                AddException(e);
-            }
+            while (itens.MoveNext())
+                list = Insert<T>(itens.Current, index, list);
             return list;
         }
 
+        /// <summary>Insira um item no idice de um <see cref="Array"/>.</summary>
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="index">Indice alvo.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void Insert<T>(T[] itens, int index, ref T[] list)
             => list = Insert<T>(itens, index, list);
 
+        /// <summary>Insira um item no idice de um <see cref="Array"/>.</summary>
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="index">Indice alvo.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void Insert<T>(T item, int index, ref T[] list)
             => list = Insert<T>(item, index, list);
 
+        /// <summary>Adicione itens que não estão no <see cref="Array"/>.</summary>
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] AddNon_Existing<T>(T item, T[] list) {
             if (!Exists(item, list))
                 return Add(item, list);
             return list;
         }
 
+        /// <summary>Adicione itens que não estão no <see cref="Array"/>.</summary>
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void AddNon_Existing<T>(T item, ref T[] list)
             => list = AddNon_Existing<T>(item, list);
 
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Add<T>(T[] itens, T[] list)
             => Insert<T>(itens, ArrayLength(list), list);
 
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Add<T>(IEnumerator<T> itens, T[] list)
             => Insert<T>(itens, ArrayLength(list), list);
 
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void Add<T>(IEnumerator<T> itens, ref T[] list)
             => list = Add<T>(itens, list);
 
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static T[] Add<T>(T item, T[] list)
             => Insert<T>(item, ArrayLength(list), list);
 
+        /// <param name="itens">Os itens seren inseridos no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void Add<T>(T[] itens, ref T[] list)
             => Insert<T>(itens, ArrayLength(list), ref list);
 
+        /// <param name="item">O iten a ser inserido no <see cref="Array"/>.</param>
+        /// <param name="list"><see cref="Array"/> alvo.</param>
         public static void Add<T>(T item, ref T[] list)
             => Insert<T>(item, ArrayLength(list), ref list);
 
+#pragma warning disable CS1591
         public static T[] Remove<T>(int index, int length, T[] list) {
-            try {
-                T[] newList = new T[list.Length - length];
-                Array.Copy(list, 0, newList, 0, index);
-                Array.Copy(list, index + length, newList, index, list.Length - (index + length));
-                return newList;
-            } catch (Exception e) {
-                AddException(e);
-                return list;
-            }
+            T[] newList = new T[list.Length - length];
+            Array.Copy(list, 0, newList, 0, index);
+            Array.Copy(list, index + length, newList, index, list.Length - (index + length));
+            return newList;
         }
 
         public static void Remove<T>(int index, int length, ref T[] list)
@@ -129,23 +118,23 @@ public static T[] Remove<T>(T item, T[] list)
         public static void Remove<T>(T item, ref T[] list)
             => list = Remove<T>(item, list);
 
-        public static void ClearArray(Array array) {
-            try { Array.Clear(array, 0, array.Length); }
-            catch (Exception e) { AddException(e); }
-        }
+        /// <summary>Limpa uma lista.</summary>
+        public static void ClearArray(Array array)
+            => Array.Clear(array, 0, array.Length);
 
+        /// <summary>Limpa uma lista.</summary>
         public static void ClearArray<T>(ref T[] array) {
-            try {
-                Array.Clear(array, 0, array.Length);
-                array = null;
-            } catch (Exception e) { AddException(e); }
+            Array.Clear(array, 0, array.Length);
+            array = null;
         }
 
+        /// <summary>Limpa uma lista.</summary>
         public static void ClearArraySafe(Array array) {
             if (!EmpytArray(array))
                 ClearArray(array);
         }
 
+        /// <summary>Limpa uma lista.</summary>
         public static void ClearArraySafe<T>(ref T[] array) {
             if (!EmpytArray(array)) {
                 ClearArray(array);
@@ -154,43 +143,28 @@ public static void Remove<T>(T item, ref T[] list)
         }
 
         public static void SeparateList<T>(T[] list, int separationIndex, out T[] part1, out T[] part2) {
-            try {
-                Array.Copy(list, 0, part1 = new T[separationIndex + 1], 0, separationIndex + 1);
-                Array.Copy(list, separationIndex + 1, part2 = new T[list.Length - (separationIndex + 1)], 0, list.Length - (separationIndex + 1));
-            } catch (Exception e) { 
-                AddException(e);
-                part1 = part2 = (T[])null;
-            }
+            Array.Copy(list, 0, part1 = new T[separationIndex + 1], 0, separationIndex + 1);
+            Array.Copy(list, separationIndex + 1, part2 = new T[list.Length - (separationIndex + 1)], 0, list.Length - (separationIndex + 1));
         }
 
         public static T[] TakeStretch<T>(int index, int length, T[] list) {
-            try {
-                T[] Res = new T[length];
-                CopyTo(list, index, Res, 0, length);
-                return Res;
-            } catch (Exception e) {
-                AddException(e);
-                return (T[])null;
-            }
+            T[] Res = new T[length];
+            CopyTo(list, index, Res, 0, length);
+            return Res;
         }
 
-        public static ReadOnlyCollection<T> ReadOnly<T>(T[] list) {
-            try {
-                return Array.AsReadOnly<T>(list);
-            } catch (Exception e) {
-                AddException(e);
-                return new ReadOnlyCollection<T>(new List<T>(0));
-            }
-        }
+        /// <summary>Cria uma lista somente de leitura.</summary>
+        /// <param name="list">A lista que será somente leitura.</param>
+        public static ReadOnlyCollection<T> ReadOnly<T>(T[] list)
+            => Array.AsReadOnly<T>(list);
 
-        public static int IndexOf(object item, Array array, int index, int length) {
-            try {
-                return Array.IndexOf(array, item, index, length);
-            } catch (Exception e) {
-                AddException(e);
-                return -1;
-            }
-        }
+        /// <summary>Cria uma lista somente de leitura.</summary>
+        /// <param name="list">A lista que será somente leitura.</param>
+        public static ReadOnlyCollection<T> ReadOnlySafe<T>(T[] list)
+            => EmpytArray(list) ? new ReadOnlyCollection<T>(new List<T>()) : ReadOnly<T>(list);
+
+        public static int IndexOf(object item, Array array, int index, int length)
+            => Array.IndexOf(array, item, index, length);
 
         public static int IndexOf(object item, Array array, int index)
             => IndexOf(item, array, index, array.Length);
@@ -205,13 +179,8 @@ public static int IndexOf(object item, Array array)
             return false;
         }
 
-        public static void CopyTo(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length) {
-            try {
-                Array.Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length);
-            } catch (Exception e) {
-                AddException(e);
-            }
-        }
+        public static void CopyTo(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length)
+            => Array.Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length);
 
         public static void CopyTo(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
             => CopyTo(sourceArray, (long)sourceIndex, destinationArray, (long)destinationIndex, (long)length);
@@ -225,18 +194,17 @@ public static void CopyTo(Array sourceArray, Array destinationArray, int length)
         public static void CopyTo(Array sourceArray, Array destinationArray)
             => CopyTo(sourceArray, 0, destinationArray, 0, sourceArray.Length);
 
-        public static void Reverse(Array array) {
-            try {
-                Array.Reverse(array, 0, array.Length);
-            } catch (Exception e) {
-                AddException(e);
-            }
-        }
+        /// <summary>Inverte uma lista.</summary>
+        public static void Reverse(Array array)
+            => Array.Reverse(array, 0, array.Length);
 
+        /// <summary>Indica se a lista está vazia.</summary>
         public static bool EmpytArray(ICollection array)
             => array == null ? true : array.Count == 0;
 
+        /// <summary>Indica o comprimento da lista.</summary>
         public static int ArrayLength(ICollection array)
             => array == null ? 0 : array.Count;
+#pragma warning restore CS1591
     }
 }

Runtime/Cobilas/Collections/IReadOnlyArray.cs

@@ -0,0 +1,8 @@
+using System.Collections;
+
+namespace Cobilas.Collections {
+    public interface IReadOnlyArray : IEnumerable {
+        int Count { get; }
+        object this[int index] { get; }
+    }
+}