public CategoriaBinaria() : base(new ElementoBinario[] {
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.String),
ElementoIListBinario <long> .ElementosTipoAceptado <long>(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long)
})
{
}
public void IDictionaryMiosAnidados()
{
const int ELEMENTOS = 10;
ElementoBinario serializador;
byte[] data;
SortedList <IdUnico, string> aux;
SortedList <IdUnico, SortedList <IdUnico, string> > dic2;
SortedList <IdUnico, SortedList <IdUnico, string> > dic = new SortedList <IdUnico, SortedList <IdUnico, string> >();
for (int i = 0; i < ELEMENTOS; i++)
{
aux = new SortedList <IdUnico, string>();
for (int j = 0; j < ELEMENTOS; j++)
{
aux.Add(new IdUnico(), DateTime.Now.ToShortTimeString());
}
dic.Add(new IdUnico(), aux);
}
serializador = ElementoBinario.GetSerializador(dic.GetType());
data = serializador.GetBytes(dic);
dic2 = (SortedList <IdUnico, SortedList <IdUnico, string> >)serializador.GetObject(data);
Assert.IsTrue(dic.GetKeys().AreEquals(dic2.GetKeys()) && Equals(dic.GetValues(), dic2.GetValues()));
}
private void SaveKeys()
{
string aux;
string dir = Path.GetTempFileName();
StringBuilder namesList = new StringBuilder();
KeyBinario serializadorKeys = new KeyBinario();
ElementoBinario stringSerialitzer = ElementoBinario.GetSerializador <string>();
aux = Path.Combine(dir, MASTERKEYFILE);
serializadorKeys.GetBytes(MasterKey).Save(aux);//como aun no tiene asignada la MasterKey puedo usar este serializador
File.Encrypt(aux);
stringSerialitzer.Key = MasterKey;
serializadorKeys.Key = MasterKey;
Directory.CreateDirectory(dir);
foreach (var item in DicKeys)
{
aux = Path.GetTempFileName();
namesList.AppendLine($"{item.Key.EscaparCaracteresXML()}{CARACTERSPLIT}{aux.EscaparCaracteresXML()}");
aux = Path.Combine(dir, aux + EXTENSIONKEY);
serializadorKeys.GetBytes(item.Value).Save(aux);
}
aux = Path.Combine(dir, IDSLIST);
File.WriteAllBytes(aux, stringSerialitzer.GetBytes(namesList.ToString()));
if (Directory.Exists(FOLDER))
{
Directory.Delete(FOLDER);
}
Directory.Move(dir, FOLDER);
}
public TareaBinaria() : base(new ElementoBinario[] {
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.String)
})
{
}
public void KeyValuePairTiposAnidados()
{
TwoKeys <IdUnico, TwoKeys <long, string> > pair = new TwoKeys <IdUnico, TwoKeys <long, string> >(new IdUnico(), new TwoKeys <long, string>(125, "Gabriel"));
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
TwoKeys <IdUnico, TwoKeys <long, string> > pairDeserializada = (TwoKeys <IdUnico, TwoKeys <long, string> >)serializador.GetObject(data);
Assert.IsTrue(pair.Key1.GetId().ArrayEqual(pairDeserializada.Key1.GetId()) && pair.Key2.Key1.Equals(pairDeserializada.Key2.Key1) && pair.Key2.Key2.Equals(pairDeserializada.Key2.Key2));
}
public void TwoKeysTiposMios()
{
TwoKeys <IdUnico, byte[]> pair = new TwoKeys <IdUnico, byte[]>(new IdUnico(), Serializar.GetBytes("Gabriel"));
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
TwoKeys <IdUnico, byte[]> pairDeserializada = (TwoKeys <IdUnico, byte[]>)serializador.GetObject(data);
Assert.IsTrue(pair.Key1.GetId().ArrayEqual(pairDeserializada.Key1.GetId()) && pair.Key2.ArrayEqual(pairDeserializada.Key2));
}
public void TwoKeysTiposBasicos()
{
TwoKeys <long, string> pair = new TwoKeys <long, string>(125, "Gabriel");
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
TwoKeys <long, string> pairDeserializada = (TwoKeys <long, string>)serializador.GetObject(data);
Assert.IsTrue(pair.Key1.Equals(pairDeserializada.Key1) && pair.Key2.Equals(pairDeserializada.Key2));
}
static bool TestClases <T>(GetElement <T> getElement)
{
T clase = getElement();
ElementoBinario serializador = ElementoBinario.GetSerializador <T>();
byte[] data = serializador.GetBytes(clase);
T claseDeserializada = (T)serializador.GetObject(data);
return(Equals(clase, claseDeserializada));
}
public void KeyValuePairTiposMios()
{
KeyValuePair <IdUnico, byte[]> pair = new KeyValuePair <IdUnico, byte[]>(new IdUnico(), Serializar.GetBytes("Gabriel"));
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
KeyValuePair <IdUnico, byte[]> pairDeserializada = (KeyValuePair <IdUnico, byte[]>)serializador.GetObject(data);
Assert.IsTrue(pair.Key.GetId().ArrayEqual(pairDeserializada.Key.GetId()) && pair.Value.ArrayEqual(pairDeserializada.Value));
}
public void KeyValuePairTiposAnidados()
{
KeyValuePair <IdUnico, KeyValuePair <long, string> > pair = new KeyValuePair <IdUnico, KeyValuePair <long, string> >(new IdUnico(), new KeyValuePair <long, string>(125, "Gabriel"));
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
KeyValuePair <IdUnico, KeyValuePair <long, string> > pairDeserializada = (KeyValuePair <IdUnico, KeyValuePair <long, string> >)serializador.GetObject(data);
Assert.IsTrue(pair.Key.GetId().ArrayEqual(pairDeserializada.Key.GetId()) && pair.Value.Key.Equals(pairDeserializada.Value.Key) && pair.Value.Value.Equals(pairDeserializada.Value.Value));
}
public void KeyValuePairTiposBasicos()
{
KeyValuePair <long, string> pair = new KeyValuePair <long, string>(125, "Gabriel");
ElementoBinario serializador = ElementoBinario.GetSerializador(pair.GetType());
byte[] data = serializador.GetBytes(pair);
KeyValuePair <long, string> pairDeserializada = (KeyValuePair <long, string>)serializador.GetObject(data);
Assert.IsTrue(pair.Key.Equals(pairDeserializada.Key) && pair.Value.Equals(pairDeserializada.Value));
}
public Reader(byte[] file, ElementoBinario customSerializador = default)
{
if (!Equals(customSerializador, default))
{
Serializador = ElementoBinario.GetSerializador <T>();
}
else
{
Serializador = customSerializador;
}
Diccionary = new SortedList <long, T>();
File = file;
}
private void LoadKeys()
{
string[] names;
string[] campos;
KeyBinario serializador = new KeyBinario();
string[] files = Directory.GetFiles(FOLDER);
SortedList <string, Key> keys = new SortedList <string, Key>();
SortedList <string, string> dicNames = new SortedList <string, string>();
ElementoBinario stringSerialitzer = ElementoBinario.GetSerializador <string>();
string masterPath = Path.Combine(FOLDER, MASTERKEYFILE);
if (File.Exists(masterPath))
{
File.Decrypt(masterPath);
MasterKey = serializador.GetObject(File.ReadAllBytes(masterPath)) as Key;
File.Encrypt(masterPath);
stringSerialitzer.Key = MasterKey;
serializador.Key = MasterKey;
for (int i = 0; i < files.Length; i++)
{
if (Path.GetExtension(files[i]) == EXTENSIONKEY)
{
keys.Add(Path.GetFileNameWithoutExtension(files[i]), serializador.GetObject(File.ReadAllBytes(files[i])) as Key);
}
else
{
names = (stringSerialitzer.GetObject(File.ReadAllBytes(files[i])) as string).Split('\n');
for (int j = 0; j < names.Length; j++)
{
campos = names[j].Split(CARACTERSPLIT);
dicNames.Add(campos[0].DescaparCaracteresXML(), campos[1].DescaparCaracteresXML());
}
}
}
foreach (var item in dicNames)
{
DicKeys.Add(item.Key, keys[item.Value]);
}
}
else
{
MasterKey = Key.GetKey(MASTERKEYS); //para la primera vez
}
}
static bool TestAny <T>(GetElement <T> getElement)
{
const int ELEMENTOS = 10;
ElementoBinario serializador;
byte[] data;
T[] arrayDeserializada;
T[] array = new T[ELEMENTOS];
for (int k = 0; k < ELEMENTOS; k++)
{
array[k] = getElement();
}
serializador = ElementoBinario.GetSerializador(array.GetType());
data = serializador.GetBytes(array);
arrayDeserializada = (T[])serializador.GetObject(data);
return(Equals(array, arrayDeserializada));
}
public void IListMio()
{
const int ELEMENTS = 10;
byte[] data;
List <IdUnico> lstDeserializada;
List <IdUnico> lst = new List <IdUnico>();
ElementoBinario serializador = ElementoBinario.GetSerializador(lst.GetType());
for (int i = 0; i < ELEMENTS; i++)
{
lst.Add(new IdUnico());
}
data = serializador.GetBytes(lst);
lstDeserializada = (List <IdUnico>)serializador.GetObject(data);
Assert.IsTrue(lst.AreEquals(lstDeserializada));
}
public void IListBasic()
{
const int ELEMENTS = 10;
byte[] data;
List <long> lstDeserializada;
List <long> lst = new List <long>();
ElementoBinario serializador = ElementoBinario.GetSerializador(lst.GetType());
for (int i = 0; i < ELEMENTS; i++)
{
lst.Add(DateTime.Now.Ticks);
}
data = serializador.GetBytes(lst);
lstDeserializada = (List <long>)serializador.GetObject(data);
Assert.IsTrue(lst.AreEquals(lstDeserializada));
}
public ListaBinaria() : base(new ElementoBinario[] {
//ID
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
//Name
ElementoBinario.ElementosTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.String),
//Tareas
new ElementoIListBinario <Tarea>(Tarea.Serializador),
//Id Tareas Hechas
ElementoIListBinario <long> .ElementosTipoAceptado <long>(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
//Fechas Tareas Hechas
ElementoIListBinario <DateTime> .ElementosTipoAceptado <DateTime>(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.DateTime),
//Id Tareas ocultas
ElementoIListBinario <long> .ElementosTipoAceptado <long>(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
//Id Listas heredadas
ElementoIListBinario <long> .ElementosTipoAceptado <long>(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.Long),
})
{
}
public void IDictionaryMios()
{
const int ELEMENTOS = 10;
ElementoBinario serializador;
byte[] data;
SortedList <IdUnico, string> dic2;
SortedList <IdUnico, string> dic = new SortedList <IdUnico, string>();
for (int i = 0; i < ELEMENTOS; i++)
{
dic.Add(new IdUnico(), DateTime.Now.ToShortTimeString());
}
serializador = ElementoBinario.GetSerializador(dic.GetType());
data = serializador.GetBytes(dic);
dic2 = (SortedList <IdUnico, string>)serializador.GetObject(data);
Assert.IsTrue(Equals(dic, dic2));
}
public void IListMioAnidada()
{
const int ELEMENTS = 10;
byte[] data;
List <IdUnico> aux;
List <List <IdUnico> > lstDeserializada;
List <List <IdUnico> > lst = new List <List <IdUnico> >();
ElementoBinario serializador = ElementoBinario.GetSerializador(lst.GetType());
for (int i = 0; i < ELEMENTS; i++)
{
aux = new List <IdUnico>();
for (int j = 0; j < ELEMENTS; j++)
{
aux.Add(new IdUnico());
}
lst.Add(aux);
}
data = serializador.GetBytes(lst);
lstDeserializada = (List <List <IdUnico> >)serializador.GetObject(data);
Assert.IsTrue(Equals(lst, lstDeserializada));
}
static Contraseña()
{
r = new Random();
reader = new GeneradorArchivoFacilDeLeer.Reader <string>(Resources.PalabrasDic, ElementoBinario.ElementoTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.String));
}
//de la lista
static Tarea()
{
Serializador = ElementoBinario.GetSerializador <Tarea>();
TodasAgrupadas = new LlistaOrdenada <long, LlistaOrdenada <Tarea> >();
Todas = new LlistaOrdenada <Tarea>();
}
public StringReader(byte[] file) : base(file, ElementoBinario.ElementoTipoAceptado(Gabriel.Cat.S.Utilitats.Serializar.TiposAceptados.String))
{
}
static Lista()
{
Serializador = ElementoBinario.GetSerializador <Lista>();
Todas = new LlistaOrdenada <long, Lista>();
}
