gistfile1.txt

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Vital.PrevidenciaFechada.DTO.Messages;

namespace FileManagementPerformancetest
{
    class Gravar
    {
        private readonly TestData _testData;

        public Gravar(TestData testData)
        {
            _testData = testData;
        }

        public void IterarGravador()
        {
            for (var c = 0; c < _testData.Iteracoes; c++)
            {
                var arquivoDto = new ArquivoUploadDTO {Extensao = "test", Arquivo = _testData.BytesArquivoTeste};
                _testData.ServicoDeArquivo.Gravar(arquivoDto);
                _testData.ListArquivosGravados.Add(arquivoDto.Id);
            }
        }
    }

    class Recuperar
    {
        private readonly TestData _testData;

        public Recuperar(TestData testData)
        {
            _testData = testData;
        }

        public void IterarRecuperador()
        {
            foreach (var arquivo in _testData.ListArquivosGravados.Select(t => new ArquivoUploadDTO() {Id = t}))
            {
                _testData.ServicoDeArquivo.Obter(arquivo);
            }
        }
    }

    class Pesquisar
    {
        private readonly TestData _testData;

        public Pesquisar(TestData testData)
        {
            _testData = testData;
        }

        public void IterarPesquisa()
        {
            foreach (var arquivo in _testData.ListArquivosGravados.Select(t => new ArquivoUploadDTO() { Id = t }))
            {
                _testData.ServicoDeArquivo.BuscarNoIndicePor(new Dictionary<string, string> { { "Extensao", "test" } });
            }
        }
    }

    class TestData
    {
        public int ThreadCount { get; set; }
        public int Iteracoes { get; set; }
        public string CaminhoRaizArquivoSalvo { get; set; }
        public string CaminhoRaizDoIndice { get; set; }
        public byte[] BytesArquivoTeste { get; set; }
        public readonly ServicoDeArquivo.ServicoDeArquivo ServicoDeArquivo;
        public List<Guid> ListArquivosGravados { get; set; }
        public DateTime InicioGravacao { get; set; }
        public DateTime FimGravacao { get; set; }
        public TimeSpan DuracaoGravacao { get; set; }
        public DateTime InicioLeitura { get; set; }
        public DateTime FimLeitura { get; set; }
        public TimeSpan DuracaoLeitura { get; set; }
        public DateTime InicioPesquisa { get; set; }
        public DateTime FimPesquisa { get; set; }
        public TimeSpan DuracaoPesquisa { get; set; }

        public TestData(IList<string> args)
        {
            ListArquivosGravados = new List<Guid>();
            BytesArquivoTeste = File.ReadAllBytes(Directory.GetCurrentDirectory() + "\\" + args[1] + "mbfile");
            ThreadCount = Convert.ToInt32(args[0]);
            Iteracoes = Convert.ToInt32(args[2]);
            CaminhoRaizArquivoSalvo = CriarRaizGerenciadorEmDisco();
            CaminhoRaizDoIndice = CriaRaizGerenciadorDeIndice();
            ServicoDeArquivo = new ServicoDeArquivo.ServicoDeArquivo(CaminhoRaizArquivoSalvo, CaminhoRaizDoIndice);
        }

        /// <summary>
        /// Cria o diretorio raiz do gerenciador de arquivo em disco caso ele não exista
        /// </summary>
        /// <returns></returns>
        private static string CriarRaizGerenciadorEmDisco()
        {
            var caminhoRaizArquivoSalvo = Directory.GetCurrentDirectory() + @"\TestePerformance\";

            if (!Directory.Exists(caminhoRaizArquivoSalvo))
                Directory.CreateDirectory(caminhoRaizArquivoSalvo);

            return caminhoRaizArquivoSalvo;
        }

        /// <summary>
        /// Cria o diretorio raiz do indice do lucene caso ele nao exista
        /// </summary>
        /// <returns></returns>
        private static string CriaRaizGerenciadorDeIndice()
        {
            var caminhoRaizDoIndice = Environment.CurrentDirectory + @"\LuceneIndex\";

            if (!(Directory.Exists(caminhoRaizDoIndice)))
                Directory.CreateDirectory(caminhoRaizDoIndice);

            return caminhoRaizDoIndice;
        }

        public void DefinirDuracaoDeGravacao()
        {
            DuracaoGravacao = FimGravacao - InicioGravacao;
        }

        public void DefinirDuracaoDeLeitura()
        {
            DuracaoLeitura = FimLeitura - InicioLeitura;
        }

        public void DefinirDuracaoDePesquisa()
        {
            DuracaoPesquisa = FimPesquisa - InicioLeitura;
        }
    }

    /// <summary>
    /// Teste de Performance do Gerenciador de Arquivo em Disco
    /// </summary>
    class PerformanceTest 
    {
        static void Main(string[] args)
        {
            try
            {
                VerificarArgumentos(args);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.ReadLine();
                return;
            }

            var testData = new TestData(args);
            ImprimirDadosDeEntradaDoTeste(testData);

            testData.InicioGravacao = DateTime.Now;

            var tasksGravacao = new Task[testData.ThreadCount];

            testData.InicioGravacao = DateTime.Now;
            for (var c = 0; c < testData.ThreadCount; c++)
            {
                Console.WriteLine("Iniciando thread de gravação número: " + (c + 1));
                tasksGravacao[c] = Task.Factory.StartNew(new Gravar(testData).IterarGravador);
            }

            Task.WaitAll(tasksGravacao);
            testData.FimGravacao = DateTime.Now;

            var tasksLeitura = new Task[testData.ThreadCount];

            testData.InicioLeitura = DateTime.Now;
            for (var k = 0; k < testData.ThreadCount; k++)
            {
                Console.WriteLine("Iniciando thread de leitura número: " + (k + 1));
                tasksLeitura[k] = Task.Factory.StartNew(new Recuperar(testData).IterarRecuperador);
            }

            testData.FimLeitura = DateTime.Now;

            var tasksPesquisa = new Task[testData.ThreadCount];

            testData.InicioPesquisa = DateTime.Now;
            for (var c = 0; c < testData.ThreadCount; c++)
            {
                Console.WriteLine("Iniciando thread de pesquisa número: " + (c + 1));
                tasksPesquisa[c] = Task.Factory.StartNew(new Pesquisar(testData).IterarPesquisa);
            }
            testData.FimPesquisa = DateTime.Now;

            Task.WaitAll(tasksPesquisa);

            testData.DefinirDuracaoDeGravacao();
            testData.DefinirDuracaoDeLeitura();
            testData.DefinirDuracaoDePesquisa();

            EscreverLogCsv(testData.ThreadCount + "," + args[1] + "," + testData.Iteracoes + "," + testData.DuracaoGravacao + "," + testData.DuracaoLeitura + "," + testData.DuracaoPesquisa);

            ImprimirDadosDeSaidaDoTeste(testData);

            Console.ReadLine();
        }

        private static void VerificarArgumentos(IList<string> args)
        {
            if (args.Count != 3)
            {
                throw new Exception("Favor inserir os argumentos: \n\n(threads) (tamanho do arquivo) (iterações)\n"
                    + "Operações: gravar, recuperar\n"
                    + "Tamanho do arquivo: 1, 5 ou 10 megabytes");
            }

            if (false == "1 5 10".Contains(args[1]))
            {
                throw new Exception("Erro: tamanho do arquivo invalido. Opções: 1, 5 e 10 megas.");
            }
        }

        private static void ImprimirDadosDeEntradaDoTeste(TestData testData)
        {
            Console.WriteLine("# CONFIG DO TESTE");
            Console.WriteLine("Quantidade de usuários: " + testData.ThreadCount);
            Console.WriteLine("Quantidade de arquivos por usuário: " + testData.ThreadCount);
            Console.WriteLine("Tamanho do arquivo: " + (testData.BytesArquivoTeste.Length / 1024) / 1024 + " Megabytes");
            Console.WriteLine("Total de arquivos a serem gravados: " + (testData.Iteracoes * testData.ThreadCount) + "\n");
        }

        private static void ImprimirDadosDeSaidaDoTeste(TestData testData)
        {
            Console.WriteLine("\n# Resultado para gravação:");
            Console.WriteLine("Tempo de Gravação em Minutos: " + testData.DuracaoGravacao.TotalMinutes);
            Console.WriteLine("Tempo de Gravação em Segundos: " + testData.DuracaoGravacao.TotalSeconds);
            Console.WriteLine("Tempo de Gravação em Milisegundos: " + testData.DuracaoGravacao.TotalMilliseconds);

            Console.WriteLine("\n# Resultado para leitura:");
            Console.WriteLine("Tempo de Leitura em Minutos: " + testData.DuracaoLeitura.TotalMinutes);
            Console.WriteLine("Tempo de Leitura em Segundos: " + testData.DuracaoLeitura.TotalSeconds);
            Console.WriteLine("Tempo de Leitura em Milisegundos: " + testData.DuracaoLeitura.TotalMilliseconds);
        }

        private static void EscreverLogCsv(string linha)
        {
            if (!File.Exists(Environment.CurrentDirectory))
            {
                using (var sw = File.CreateText(Environment.CurrentDirectory + "\\resultado.txt"))
                {
                    sw.WriteLine(linha);
                }
            }
            else
            {
                using (var sw = File.AppendText(Environment.CurrentDirectory + "\\resultado.txt"))
                {
                    sw.WriteLine(linha);
                }
            }
        }
    }
}