-
Notifications
You must be signed in to change notification settings - Fork 1
/
Oracle.Utils.cs
239 lines (215 loc) · 8.3 KB
/
Oracle.Utils.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
/*-----------------------------------------------*
* Programado por Alain Ramírez Cabrejas *
* Camagüey, Ciudad de los Tinajones. *
* Julio 2006 *
*-----------------------------------------------*
*/
using System;
using System.Collections;
using System.Data;
using System.Text;
using Oracle.DataAccess.Client;
namespace Oracle.Utils
{
/// <summary>
/// Clase encargada de métodos generales de la aplicación
/// </summary>
[History("11/07/2007","Arreglada la creación de parámetros a partir de OracleNative")]
[History("01/06/2007","Corrección de método CreateOracleColumn")]
public sealed class OracleUtils
{
#region Create Oracle Parameters
/// <summary>
/// Crea un parametro Oracle de tipo <c>VARCHAR2</c>
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <param name="value">Valor del parámetro</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateVarchar2(string name, string value)
{
return OracleNative.CreateParams(name,OracleDbType.Varchar2,value,ParameterDirection.Input);
}
/// <summary>
/// Crea un parametro Oracle de tipo <c>DATE</c>.
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <param name="value">Valor del parámetro</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateDateTime(string name, DateTime value)
{
return OracleNative.CreateParams(name, OracleDbType.Date, value, ParameterDirection.Input);
}
/// <summary>
/// Crea un parametro Oracle de tipo <c>Cursor Ref</c>.
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateCursorRefOut(string name)
{
return OracleNative.CreateParams(name, OracleDbType.RefCursor, ParameterDirection.Output);
}
/// <summary>
/// Crea un parámetro Oracle de tipo <c>BLOB IN</c>
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <param name="value">Contenido del BLOB</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateBlob(string name, object value)
{
return OracleNative.CreateParams(name, OracleDbType.Blob, value, ParameterDirection.Input);
}
/// <summary>
/// Crea un parametro Oracle de tipo <c>NUMBER(n) OUT</c>.
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateInt32Out(string name)
{
return OracleNative.CreateParams(name, OracleDbType.Int32, ParameterDirection.Output);
}
/// <summary>
/// Crea un parametro Oracle de tipo <c>NUMBER(n)</c>.
/// </summary>
/// <param name="name">Nombre del parámetro</param>
/// <param name="value">Valor del parámetro</param>
/// <returns>Retorna un valor de tipo OracleParameter</returns>
public static OracleParameter CreateInt32(string name, int value)
{
return OracleNative.CreateParams(name, OracleDbType.Int32, value, ParameterDirection.Input);
}
/// <summary>
/// Crea una columna con las propiedades extendidas para Oracle
/// </summary>
/// <param name="columnName">Nombre de la columna</param>
/// <param name="columnType"></param>
/// <returns>DataColum</returns>
public static DataColumn CreateOracleColumn(string columnName, OracleDbType columnType)
{
DataColumn dc = new DataColumn(columnName, OracleNative.OracleToFramework(columnType));
dc.ExtendedProperties["OraDbType"] = (byte)columnType;
return dc;
}
#endregion
}
/// <summary>
/// Utilitarios generales
/// </summary>
public static class Utils
{
/// <summary>
/// <para>Libera los objetos pasados como parámetros utilizando la interface IDisposable</para>
/// <para>si la tienen y luego asigna null a estos</para>
/// </summary>
/// <param name="objs">Arreglo de objetos a liberar</param>
public static void DisposeAndNull(params IDisposable[] objs)
{
if (objs != null && objs.Length != 0)
for (int i = 0; i < objs.Length; i++)
if (objs[i] != null)
{
objs[i].Dispose();
objs[i] = null;
}
}
/// <summary>
/// Libera los objetos que son de la interfase IList pasados como parámetros
/// y luego asigna null a estos (Ej. Array)
/// </summary>
/// <param name="objs"></param>
public static void ClearAndNull(params IList[] objs)
{
if (objs != null && objs.Length != 0)
{
for (int i = 0; i < objs.Length; i++)
{
if (objs[i] != null)
{
objs[i].Clear();
objs[i] = null;
}
}
}
}
}
/// <summary>
/// Clase encargada de la conversión numérica de una base a otra
/// </summary>
public static class BaseConverter
{
/// <summary>
///Convierte un número de cualquier base entre 2 y 36 a cualquier base entre 2 y 36
/// </summary>
/// <param name="numberAsString">Número a convertir</param>
/// <param name="fromBase">La base desde la cual quiere convertir (Entre 2 y 36).</param>
/// <param name="toBase">La base a la cual se convertirá (Entre 2 y 36).</param>
/// <returns>The number converted from fromBase to toBase.</returns>
public static string ToBase(string numberAsString, ushort fromBase, ushort toBase)
{
ulong base10 = ToBase10(numberAsString, fromBase);
return FromBase10(base10, toBase);
}
/// <summary>
///Convierte un número desde cualquier base entre 2 y 36 a base 10.
/// </summary>
/// <param name="encodedNumber">Número a convertir.</param>
/// <param name="fromBase">La base desde la cual se va a convertir (Entre 2 y 36).</param>
/// <returns>El número convertido a base 10.</returns>
public static ulong ToBase10(string encodedNumber, ushort fromBase)
{
// If the from base is 10, simply parse the string and return it
if (fromBase == 10)
{
return UInt64.Parse(encodedNumber);
}
// Ensure that the string only contains upper case characters
encodedNumber = encodedNumber.ToUpper();
// Go through each character and decode its value.
int length = encodedNumber.Length;
ulong runningTotal = 0;
for (int index = 0; index < length; index++)
{
char currentChar = encodedNumber[index];
// Anything above base 10 uses letters as well as numbers, so A will be 10, B will be 11, etc.
uint currentValue = Char.IsDigit(currentChar) ? (uint)(currentChar - '0') :
(uint)(currentChar - 'A' + 10);
// The value which of the character represents depends on its position and it is calculated
// by multiplying its value with the power of the base to the position of the character, from
// right to left.
runningTotal += currentValue * (ulong)Math.Pow(fromBase, length - index - 1);
}
return runningTotal;
}
/// <summary>
///Convierte un número de base 10 a cualquier base entre 2 y 36.
/// </summary>
/// <param name="number">El número a convertir.</param>
/// <param name="toBase">La base a la cual se desea convertir (Entre 2 y 36).</param>
/// <returns>El número convertido desde la base 10.</returns>
public static string FromBase10(ulong number, ushort toBase)
{
//If the to base is 10, simply return the number as a string
if (toBase == 10)
{
return number.ToString();
}
// The number has to be divided by the base it needs to be converted to
// until the result of the division is 0. The modulus of the division
// is used to calculate the character that represents it
StringBuilder runningResult = new StringBuilder();
while (number > 0)
{
ulong modulus = number % toBase;
if (modulus < 10)
{
runningResult.Insert(0, modulus);
}
else
{
runningResult.Insert(0, (char)('A' + modulus - 10));
}
number = (number - modulus) / toBase;
}
return runningResult.ToString();
}
}
}