/// <summary>
/// Metodo encargado de hacer la lectura de un arreglo bytes
/// a partir de un ruta de archivo
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <param name="extencion"></param>
/// <returns></returns>
public byte[] ReadBytesPath(string path, ExtencionFile extencion)
{
byte[] arrayBytes = null;
if (File.Exists(path) && dictionaryResolveFile.ContainsKey(extencion) && path.ToUpper().EndsWith(extencion.ToString().ToUpper()))
{
return(File.ReadAllBytes(path));
}
return(arrayBytes);
}
public void Read()
{
IFileManager FileManager = new FileManager();
String fileName = "";
ExtencionFile extencionFile = ExtencionFile.txt;
//Manejo de genericos para el objeto de respuesta
FileTxtResult fileResult = FileManager.Read <FileTxtResult>(fileName, extencionFile);
Assert.IsNotNull(fileResult);
}
public void Write()
{
IFileManager FileManager = new FileManager();
String fileName = "";
byte[] arrayBytes = File.ReadAllBytes(fileName);
String fileNameDestination = "";
ExtencionFile extencionFile = ExtencionFile.txt;
Assert.IsTrue(FileManager.Write(fileNameDestination, arrayBytes, extencionFile));
}
/// <summary>
/// Graba en un archivo y resuelve la clase a implementar segun
/// la extencion del archivo
/// </summary>
/// <param name="fullName">nombre completo del archivo donde se almacenara</param>
/// <param name="bytes">arreglo de bytes a grabar</param>
/// <param name="extencion">extencion a grabar</param>
/// <returns></returns>
public bool Write(string fullName, byte[] bytes, ExtencionFile extencion)
{
if (dictionaryResolveFile.TryGetValue(extencion, out Type type))
{
Object obj = Activator.CreateInstance(type);
if (obj is IFileManager)
{
return((obj as IFileManager).Write(fullName, bytes, extencion));
}
}
return(false);
}
/// <summary>
/// Metodo encargado de la lectura de un arreglo de bytes
/// para comprender su respuesta
/// </summary>
/// <typeparam name="T">retorna un objeto de respuesta</typeparam>
/// <param name="bytes"></param>
/// <param name="extencion"></param>
/// <returns></returns>
public T ReadBytes <T>(byte[] bytes, ExtencionFile extencion) where T : FileResult
{
if (dictionaryResolveFile.TryGetValue(extencion, out Type type))
{
Object obj = Activator.CreateInstance(type);
if (obj is IFileManager)
{
return((obj as IFileManager).ReadBytes <T>(bytes, extencion));
}
}
return(null);
}
/// <summary>
/// Metodo encargado de la lectura de archivos resuleve
/// el objeto de respuesta por medio de generics
/// </summary>
/// <typeparam name="T">objeto de respuesta </typeparam>
/// <param name="fullName">name file donde se encuentra el archivo</param>
/// <param name="extencion">extencio de archvio que se va a trabajar</param>
/// <returns></returns>
public T Read <T>(string fullName, ExtencionFile extencion) where T : FileResult
{
if (File.Exists(fullName) && dictionaryResolveFile.TryGetValue(extencion, out Type type))
{
//Se cra una instancia de objeto al partir del tipo
Object obj = Activator.CreateInstance(type);
if (obj is IFileManager)
{
return((obj as IFileManager).Read <T>(fullName, extencion));
}
}
return(null);
}
/// <summary>
/// Metodo encarado de hacer la lectura del texto
/// a partir de arreglo de bytes
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="bytes"></param>
/// <param name="extencion"></param>
/// <returns></returns>
public T ReadBytes <T>(byte[] bytes, ExtencionFile extencion) where T : FileResult
{
if (typeof(T) != typeof(FileTxtResult))
{
throw new CofingTypeNotSupportedException();
}
string line = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
return(new FileTxtResult()
{
Path = "", Extencion = extencion, TextValue = line
} as T);
}
/// <summary>
/// Metoto encargado de grabar un archivo plano
/// </summary>
/// <param name="fullName">nombre completo donde sera almacenado el archivo</param>
/// <param name="bytes">arreglo de bytes que se almacenaran</param>
/// <param name="extencion">extencion de archivo a almacenar</param>
/// <returns>retorna si fue o no capas de grabar</returns>
public bool Write(string fullName, byte[] bytes, ExtencionFile extencion)
{
if (!fullName.EndsWith(extencion.ToString()))
{
throw new ExtencionNotSupportedException();
}
String str = Encoding.Default.GetString(bytes);
if (!String.IsNullOrEmpty(str))
{
using (StreamWriter file = new StreamWriter(fullName))
{
file.Write(str);
return(true);
}
}
return(false);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <param name="extencion"></param>
/// <returns>retorna el objeto de repuesta</returns>
public T Read <T>(string fullName, ExtencionFile extencion) where T : FileResult
{
if (typeof(T) != typeof(FileTxtResult))
{
throw new CofingTypeNotSupportedException();
}
if (!fullName.EndsWith(extencion.ToString()))
{
throw new ExtencionNotSupportedException();
}
using (StreamReader sr = new StreamReader(fullName))
{
String line = sr.ReadToEnd();
return(new FileTxtResult()
{
Path = fullName, Extencion = extencion, TextValue = line
} as T);
}
}
/// <summary>
/// Metodo sobre escrito pero no implmentado
/// </summary>
/// <param name="path"></param>
/// <param name="extencion"></param>
/// <returns></returns>
public byte[] ReadBytesPath(string path, ExtencionFile extencion)
{
throw new NotImplementedException();
}