Nesta dica vou mostrar uma forma de verificar se já existe um processo do seu aplicativo em execução na máquina com C#.
Para isso devemos utilizar a classe de diagnosticos nativa.
using System.Diagnostics;
Primeiro iremos saber qual é o processo do seu aplicativo
var seuProcesso = Process.GetCurrentProcess();
Depois iremos procurar se existe um outro processo com o mesmo nome que ele na lista de processos do windows
var processoIgualExecutando = Process.GetProcessesByName(seuProcesso.ProcessName).FirstOrDefault(p => p.Id != seuProcesso.Id);
Pronto com esse var já é possível saber se existe um processo aberto igual ao que você está abrindo.
Com isso pode-se por exemplo impedir que seja aberto um novo processo, evitando dois iguais sendo executados.
if (processoIgualExecutando != null)
{ seuProcesso.Kill(); }
Na dica de hoje irei mostrar como selecionar um valor em uma lista através de select, sim select parecido com os de sql.
Imagine que teremos uma lista de clientes proveniente de um select simples no banco como select * from cliente.
Os campos desta tabela são:
int id
string Nome
string Telefone
string CPF
E eu terei que ter uma classe com estes mesmos campos, o nome dela será CadCliente.
Pronto agora é só ter um IEnumerable dessa classe de clientes, e um método que selecione os valores no banco e converta em uma lista de CadCliente.
Como o foco não é o método que seleciona vou dar um nome qualquer a ele.
IEnumerable<CadCliente> cadClientes = metodoQueRetornaListaDeClientes();
Agora vou criar uma variável var para receber a classe do cliente que desejo selecionar.
poderia ser uma instância da classe, mas vou aproveitar para mostrar como inicializar uma variável var com valor nulo. (Bônus duas dicas em uma!!)
var clienteSelecionado = (IEnumerable<CadCliente>)null;
clienteSelecionado = from CadCliente cli in cadClientes where cli.Nome == "Mateus" select cli;
Neste comando posso utilizar dos métodos em C# mesmo para refinar minha busca como por exemplo:
clienteSelecionado = from CadCliente cli in cadClientes where cli.Nome.Contains("Mateus") select cli;
Nesta dica vamos realizar a comparação entre datas e descobrir quantos dias existem entre elas.
No caso irei comparar quantos dias estão entre o dia 28/11/2015 e a data atual 30/11/2015.
Vamos setar a data desejada para a comparação.
DateTime dtComparacao = new DateTime();
dtComparacao = Convert.ToDateTime("28/11/2015");
Depois comparar com a outra data, no caso estou pegando a data atual e extrair a diferença em dias.
TimeSpan timeSpanDif = DateTime.Now.Subtract(dtComparacao);
int dias = 0;
DateTime dif = new DateTime(timeSpanDif.Ticks);
dias = dif.DayOfYear;
Nesta dica irei mostrar uma forma de ter a informação de memória RAM da máquina com C#.
Primeiramente para esclarecer, a classe que será utilizada faz parte da biblioteca do VB, por tanto, teremos que adicioná-la ao projeto.
E vou colocar o using do namespace para encurtar seu nome de acesso.
using Microsoft.VisualBasic.Devices;
Agora os métodos, irei criar dois, um para retornar a memória ram instalada e outro para a que está em uso no instante da execução do método.
public int MemoriaInstalada()
{ int ramInstalada = 0; ComputerInfo cInfo = new ComputerInfo(); var bytes = cInfo.TotalPhysicalMemory; var memoriaKB = bytes / 1024; ramInstalada = Convert.ToInt32(memoriaKB) / 1024; return ramInstalada;
}
public int MemoriaEmUso()
{ int ramEmUso = 0; ComputerInfo cInfo = new ComputerInfo(); var bytes = cInfo.AvailablePhysicalMemory; var memoriaKB = avaliB / 1024; int ramEmUso = Convert.ToInt32(memoriaKB) / 1024; return ramEmUso;
}
Vale adicionar que a classe ComputerInfo tem várias outras informações interessantes, dê uma pesquisada.
Uma dica simples para deletar arquivos ou pastas com C#, para isso será necessário passar como parâmetro o caminho absoluto do arquivo ou da pasta como por exemplo, quero deletar uma pasta de nome "teste" que está no D:, então o parâmetro deverá conter D:\teste
public void Delete(string caminhoArquivo) { System.IO.FileInfo f = new FileInfo(caminhoArquivo); f.Delete(); }
Caso o arquivo ou pasta esteja dentro do seu diretório da aplicação pode-se capturar o diretório da aplicação para não ter que passar o caminho absoluto sempre, como por exemplo tenho uma pasta de nome "XML" dentro do diretório da minha aplicação PAra ter o diretório corrente é só usar string currentDirectory = DirectoryHelper.GetCurrentDirectoryPath(); agora é só concatenar o nome da minha pasta "XML"
Obs. Se fosse minha intenção excluir um arquivo deveria conter na string do caminho "Pasta\nome do arquivo . extensão" "C:\Teste\arquivo.txt"
Nesta dica irei mostrar uma forma de serem criados e também à verificar a existência de diretórios com C#
Primeiro no método vamos instanciar as informações do diretório, após verificar sua existência e caso não haja será criado. public bool CriarDir(string caminhoDiretorio) { System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(caminhoDiretorio);
if (!dInfo.Exists) { dInfo = System.IO.Directory.CreateDirectory(destDirectoryPath); }
if (!dInfo.Exists) { throw new DirectoryNotFoundException("Não é possível criar/encontrar o diretório."); } else return true; }
O método também poderia ser modificado para só ser criado mediante um parâmetro. public bool CriarDir(string caminhoDiretorio, bool criaDiretorio) { System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(caminhoDiretorio);
if (!dInfo.Exists) { if(criaDiretorio) dInfo = System.IO.Directory.CreateDirectory(destDirectoryPath); else return false; }
if (!dInfo.Exists) return false; else return true; }
Na postagem de hoje mostrarei como descobrir através de select quanto de memória ram o sql server está consumindo da máquina.
Este valor retornado é proveniente do próprio gerenciamento do SQL Server.
SELECT counter_name, cntr_value AS 'Total Server Memory (KB)'
FROM sys.dm_os_performance_counters
WHERE counter_name = 'Total Server Memory (KB)'
Como o foco nesta postagem é a memória em uso limitei com o where para somente este valor, mas existem muitos outros retornados por essa mesma tabela.
Faça um select de todos os valores para conferir.
SELECT * FROM sys.dm_os_performance_counters
Hoje irei mostrar uma forma de reiniciar o contador do identity em uma tabela. Isso é bastante útil quando se tem uma tabela com valores constantemente zerados ou quando é preciso que a tabela comece seu trabalho desde o início.
Para isso vamos utilizar uma tabela “Operador” com a seguinte estrutura:
CREATE TABLE [dbo].[Operador](
[IdOperador] [int] IDENTITY(1,1) NOT NULL,
[Email] [varchar](200) NULL,
[Senha] [varchar](max) NULL
CONSTRAINT [PK_Operador] PRIMARY KEY CLUSTERED (IdOperador))
Se você tiver nessa tabela 5 registros, serão gerados Ids sequenciais para o IdOperador de 1 até 5:
Ao apagar todos os registros dessa tabela com o Comando DELETE e for inserido um novo registro ele receberá IdOperador = 6, isso ocorre porque toda vez que um registro é inserido, o SQL recupera o próximo ID de uma seqüência que não é alterada para um número menor ou zerada por exemplo.
Para reiniciar a numeração de uma coluna Identity de uma tabela do SQL Server, utilize o comando:
DBCC CHECKIDENT('[tabela]', RESEED, 0)
Aplicando o comando seguindo o exemplo, ficaria assim:
DBCC CHECKIDENT('Operador', RESEED, 0)
Isso fará que o próximo registro inserido receba IdOperador = 1.
Vale observar que este ID não necessariamente deverá ser 0.
DBCC CHECKIDENT('Operador', RESEED, 50)
Neste caso o próximo ID seria o 51.
Nesta postagem irei mostrar uma forma simples de realizar comunicação com leitor de código de barras através da porta serial. Tanto a abertura de comunicação, quanto encerramento, além da leitura do código através da porta. No caso eu utilizzei um leitor a laser fixo, esses bastante utilizados em mercado.
Primeiramente é necessário declarar a classe de portas seriais public SerialPort PortaSerial { get; set; }
Com isso vou criar o método de abertura de comunicação (abertura de porta) para o meu aplicativo saber que existe comunicação com aquela porta e também que se trata de um leitor por exemplo public bool AbreComunicacao(string portaSerial) { bool retorno = false;
try { portaSerial = portaSerial.AsString().Trim();
if (PortaSerial != null && PortaSerial.IsOpen) { EncerraComunicação(); }
PortaSerial = new SerialPort(portaSerial);
if (!PortaSerial.IsOpen) { PortaSerial.Open(); }
if (PortaSerial.IsOpen) { retorno = true; } else { retorno = false; } } catch (Exception e) { //Exibir uma possível mensagem ou realizar algum tratamento de exceção }
return retorno; }
E para encerrar a comunicação o método é este public bool EncerraComunicação() { bool retorno = false;
try { if (PortaSerial != null && PortaSerial.IsOpen) PortaSerial.Dispose();
if (PortaSerial == null || !PortaSerial.IsOpen) { retorno = true; } else { retorno = false; }
} catch(Exception ex) { //Exibir uma possível mensagem ou realizar algum tratamento de exceção }
return retorno; }
Agora na leitura vou colocar um método que também retorna verdadeiro ou falso para saber se houve leitura e a leitura será retornado como out no parâmetro, mas poderia por exemplo ter o retorno direto da leitura e caso não fosse possível ler retornar uma string vazia, são várias as possibilidades depende de como você deseja utilizar o método. Vamos à ele que é bastante simples. public bool LePorta(out string leitura) { bool retorno = false; leitura = "";
try { if (PortaSerial != null && PortaSerial.IsOpen) { leitura = PortaSerial.ReadExisting(); retorno = true; } else { retorno = false; } } catch(Exception ex) { //Exibir uma possível mensagem ou realizar algum tratamento de exceção }
return retorno; }
Nesta postagem irei frisar algumas particularidades importantes da NFCe, visando
facilitar para desenvolvedores e interessados descrevendo as em um único local.
Somente como observação não se esqueçam que este post é de outubro de 2015 então aqui estarão
alguns pontos que estão em produção no momento, como são previstas várias alterações no projeto
do NFCe pode ocorrer ao longo do tempo.
- Prazo para cancelamento de uma venda é de 24 horas (anteriormente já foi de 30 minutos).
- Como na NFe pode haver a inutilização de numeração. Após emitir a NFC-e número 100 , foi emitida a NFC-e número 120. Use o programa para inutilizar as NFC-e do número 101 a 119.
- Certificado digital pode ser A1(armazenado no pc) ou A3(cartão).
- Pode ser o mesmo certificado digital da NF-e.
- Arquivos xml devem ser armazenados por (ano corrente + 5 anos) pelo contribuinte.
- Valor máximo da NFCe 10.000,00 sem identificação do destinatário e 200.000,00 com identificação, ambas parametrizáveis por UF (ou seja cada estado pode ter seus próprios valores limite).
- DANFE é uma impressão simplificada da venda com intenção de facilitar a consulta do consumidor final no ambiente da Sefaz. (Documento fiscal).
- Detalhe da Venda é um documento não fiscal, com a finalidade de detalhar para o consumidor final os itens de mercadoria que compõem a operação de venda realizada.
- O contribuinte pode solicitar o envio do arquivo xml por e-mail desde que antes de iniciada a emissão da NFCe.
- Cada estado pode optar por permitir não imprimir o Danfe e enviá-lo apenas por e-mail.
- Detalhe da venda não possui modelo específico, apenas informações obrigatórias por item(código, descrição, quantidade, valor unitário e valor total) e de totalização (valor total, forma de pagamento, valor pago e troco).
- O Danfe tem formato específico e está descrito no manual de especificações técnicas do Danfe NFCe que pode ser acessado aqui
- No Danfe deverá ser exibido o valor aprox dos tributos (valor em reais). Lei de olho no imposto.
- QR code deverá usar no seu hash o algoritmo sha1 e os tipos de caracteres UTF-8.
- NFCe não pode ter PISST, COFINSST, IPI, dados da transportadora e cobrança.
Em caso de contingência
- Em caso de problemas técnicos ou operacionais, o contribuinte poderá utilizar a contingência offline que consiste na emissão da NFC-e, sem a prévia autorização do Fisco,
devendo, nesse caso, ser transmitida à SEFAZ em um prazo de até 24h após a venda. A decisão da emissão da NFC-e em contingência é exclusiva do contribuinte e não depende de autorização do Fisco.
(Cada estado pode definir sua forma de contingência, no estado de São Paulo por exemplo a contingência da NFCe é o documento 59 SAT).
A contingência off-line também tem manual específico.
- Arquivo digital em modo contingência deve conter I - motivo da entrada em contingência; II - data, hora com minutos e segundos do seu início.
- Obrigatoriamente deve ser impressa no DANFE a mensagem “EMITIDA EM CONTINGÊNCIA”.
- Obrigatoriamente devem ser impressas duas vias do DANFE ou o contribuinte deve guardar o arquivo xml(não podendo alegar problemas técnicos em caso de perda do arquivo).
Em caso de denegação
Na hipótese de denegação da Autorização de Uso da NFC-e, prevista no inciso II:
1 - O arquivo digital transmitido ficará arquivado na Secretaria da Fazenda para consulta, identificado como “Denegada a Autorização de Uso”;
2 - Não será possível sanar a irregularidade e solicitar nova Autorização de Uso da NFC-e para NFC-e de mesma série e número.
Aqui vou deixar um vídeo com mais algumas informações interessantes sobre o assunto do respeitado Claudenir da Daruma.
Nesta dica mostrarei como é simples converter um valor inteiro para binario.
Vamos ao método.
Ele terá como parâmetro o int com o valor a ser convertido e retornará uma string com o binário.
Na dica de hoje mostrarei como adicionar um ícone na área de notificações do windows (Aquela perto do relógio).
Começando com o objeto do ícone.
System.Windows.Forms.NotifyIcon meuIcone;
Depois indicando o local do arquivo de ícone.
Obs. O .ico é a extensão específica de ícones.
string caminhoIcon = @"D:\meuIcone.ico";
Inicializando e configurando o ícone.
meuIcone = new System.Windows.Forms.NotifyIcon();
Este é o texto que aparecerá quando o usuário colocar o mouse sobre o ícone (tooltip).
meuIcone.Text = "Título do meu ícone";
Setando se o ícone estará visível ou não. É bastante útil quando deseja-se que o ícone apareça em uma determinada situação ou evento.
meuIcone.Visible = true;
Desenhando o ícone com a imagem carregada anteriormente
meuIcone.Icon = new System.Drawing.Icon(caminhoIcon);
Pronto seu ícone será exibido.
Mas podemos adicionar algumas propriedades a mais e mais funcionalidades para ele do que somente exibí-lo.
Como por exemplo adicionar eventos. Este é um evento de duplo clique do mouse.
meuIcone.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(meuIcone_MouseDoubleClick);
Ou então adicionar um menu de contexto (É aquele que aparece quando clicamos com o botão direito do mouse sobre ele).
Vou mostrar um menu com dois itens, um para exibir seu aplicativo e outro para enviar um comando de fechar.
System.Windows.Forms.MenuItem[] items = new System.Windows.Forms.MenuItem[2];
System.Windows.Forms.MenuItem item = new System.Windows.Forms.MenuItem("Abrir o " + Globals.assData.Name);
System.Windows.Forms.MenuItem item2 = new System.Windows.Forms.MenuItem("Sair do " + Globals.assData.Name);
item.Click += item_Click;
item2.Click += item2_Click;
items[0] = item;
items[1] = item2;
meuIcone.ContextMenu = new System.Windows.Forms.ContextMenu(items);
E estes são os eventos de clique simples que serão acionado no menu de contexto.
private void item2_Click(object sender, EventArgs e)
{ Close();
}
Também é possível adicionar uma mensagem em forma de balloon (Aquelas mensagens que geralmente são temporárias e aparecem em cima do ícone)
meuIcone.BalloonTipText = "Meu aplicativo";//Texto exibido no balloon
meuIcone.ShowBalloonTip(400); //tempo em que o balloon será exibido
Esta dica é para converter facilmente uma string qualquer em seu valor hexadecimal correspondente. O tema surgiu quando eu estava programando
um projeto para NFCe onde alguns valores são utilizados em sua forma hexadecimal para formar uma string do QrCode.
Aqui segue uma forma de obter este valor.
Vou converter o texto "teste" para hexadecimal;
string texto = "teste";
Aqui converto a string em um vetor de bytes (hexadecimal), você deverá ficar atento a qual Encoding deseja utilizar (UTF7, UTF8, UTF32, ASCII etc).
byte[] ba = System.Text.Encoding.UTF8.GetBytes(texto);
Agora vou transformar este vetor de bytes em string novamente, com isso já terei minha string em hexadecimal
var hexString = BitConverter.ToString(ba);
string retorno = hexString;
A string retornada vem com "-" como separador de cada um dos bytes, caso queira removê-lo é só utilizar o método de replace;
retorno.Replace("-", "");
Agora é a vez dos arquivos, algumas vezes precisamos conferir a versão de algum arquivo ou dll para saber
se realmente a versão que está sendo utilizada é a desejada ou mais atualizada.
Existe uma forma simples de saber isso dentro do seu aplicativo com C#.
Vamos declarar uma string com a pasta corrente. (somente para o exemplo o arquivo pode estar em qualquer
caminho desde que ele esteja acessível)
Agora vamos verificar se a DLL ou arquivo desejado está neste caminho.
Obs.: o "dll" que se segue deverá ser trocado pelo nome do arquivo.
bool localizada = System.IO.File.Exists(diretorio + @"\" + dll);
Se for localizada iremos capturar a versão
if (localizada)
{ System.Diagnostics.FileVersionInfo arquivo = System.Diagnostics.FileVersionInfo.GetVersionInfo(path + @"\" + dll); string versaoArquivo = arquivo.FileVersion;
}
Pronto temos uma string "versaoArquivo" com a versão do arquivo.
Aqui vai uma forma de enviar string para a impressora utilizando o spool do windows.
Este método é bastante utilizado para impressoras não fiscais, pois com ele se tem um envio genérico para o spool do windows,
não dependendo de DLLs de terceiros.
Algumas vantagens de se utilizar o spool são:
- O windows gerencia, então caso seja enviado conteúdo para impressão e a impressora esteja desligada, é só liga-la
que a impressão será realizada.
- Caso acabe o papel no meio da impressão, pode-se colocar mais que a impressão continuará de onde parou.
- A fila de impressão também é gerenciada pelo windows
Criei dois métodos para facilitar a chamadapelo aplicativo, um publico que será o método chamado em qualquer lugar da aplicação
e um privado para ninguém ter acesso a ele sem necessidade.
Mas antes disso precisamos criar uma classe que será a estrutura do documento enviado.
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
private class DocInfoA
{ [MarshalAs(UnmanagedType.LPStr)] public string pDocName; [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile; [MarshalAs(UnmanagedType.LPStr)] public string pDataType;
}
Depois importaremos os métodos do spool que iremos utilizar.
private bool EnviaBytesParaImpressora(IntPtr pBytes, Int32 tamanhoTexto)
{ Int32 dwWritten = 0; IntPtr hPrinter = new IntPtr(0); DocInfoA di = new DocInfoA(); bool retorno = false;
try { //pDocName = Nome do documento, pode ser o nome de sua preferência di.pDocName = "Impressora Nao Fiscal"; di.pDataType = "RAW";
//Inicia comunicação com a impressora if (OpenPrinter(NomeImpressora.Normalize(), out hPrinter, IntPtr.Zero)) { //Abre o documento if (StartDocPrinter(hPrinter, 1, di)) { //Insere uma página if (StartPagePrinter(hPrinter)) { //Envia o conteúdo para impressora retorno = WritePrinter(hPrinter, pBytes, tamanhoTexto, out dwWritten);
EndPagePrinter(hPrinter); }
EndDocPrinter(hPrinter); }
ClosePrinter(hPrinter); } else { retorno = false; } } //Caso algum problema ocorra a comunicação com a impressora é fechada para não ficar ocupando-a catch { ClosePrinter(hPrinter); }
Existem algumas formas de se saber quanto de memória o PC tem, nesta dica motrarei uma delas utilizando apenas C#.
No System.Management existem as classes ManagementObject e ManagementObjectSearcher, da qual iremos utilizar.
Primeiro uma variável que servirá para armazenar o valor da memória.
int memoriaRam = 0;
O ManagementObjectSearcher trabalha com uma espécie de consulta, como se fosse um comando SQL, no nosso caso utilizaremos esta.
string Consulta = "SELECT MaxCapacity FROM Win32_PhysicalMemoryArray";
ManagementObjectSearcher objetoPesquisado = new ManagementObjectSearcher(Consulta);
Feito isso iremos somar todos os valores encontrados para a memória RAM.
foreach (ManagementObject WniPART in objetoPesquisado.Get())
{ UInt32 tamanhoKB = Convert.ToUInt32(WniPART.Properties["MaxCapacity"].Value); UInt32 tamanhoMB = tamanhoKB / 1024; memoriaRam += Convert.ToInt32(tamanhoMB);
}
Concluído o foreach teremos o valor em MB da memória RAM do PC
Neste simples tutorial irei mostrar como alterar a cor de um objeto WPF através do C#.
Os objetos no WPF são:
<Rectangle x:Name="retang">
<ListView x:Name="list">
Para mostrar que é possível utilizar da mesma forma para objetos diferentes.
Trabalharemos com cores no formato RGB. Imagine que quero um tom de cinza claro, então
vou setar uma string com o seguinte texto "190,190,190".
string cor = "191,191,191";
//Separando o R, G e B
var converterBrush = new System.Windows.Media.BrushConverter();
string[] coresRGB = cor.Split(',');
//criando a cor
var cor = Color.FromArgb(coresRGB[0].ToInt32(), coresRGB[1].ToInt32(), coresRGB[2].ToInt32());
var brush = (System.Windows.Media.Brush)converterBrush.ConvertFromString("#" + cor.Name);
//Pintando Rectangle e o ListView
retang.Fill = brush;
list.Background = brush;
Aqui vou mostrar uma forma de criar um número randômico com C#.
Existem n utilizações para isso, mas a necessidade comigo surgiu quando estava
desenvolvendo uma dll de comunicação com SATs onde é necessário à cada método
enviado, passar um número randômico como parâmetro.
Utilizaremos a classe Random que está no namespace System mesmo.
Random random = new Random();
int randomicoInteiro = random.Next(0, 999999);
Existe também a possibilidade de se trabalhar com double, neste caso é só
substituir o .Next por .NextDouble
Nesta dica iremos pegar peso de uma balança Toledo através da DLL P05 com C#.
Primeiro vamos declarar os métodos utilizados.
[DllImport(P05.DLL")]
public static extern int AbrePorta(int porta, int velocidade, int dataBits, int paridade);
[DllImport(P05.DLL")]
public static extern int FechaPorta();
[DllImport(P05.DLL")]
public static extern int PegaPeso(int tipoEscrita, StringBuilder peso, string diretorio);
O tipo escrita serve para disponibilizar em arquivo texto quando 0 e quando 1 é para disponibilizar na área de transferência
O diretório é para indicar onde será salvo o arquivo.
Após isso vou criar um método que irá abrir a porta, pegar o peso e fechá-la.
public decimal RetornaPeso(int portaCom)
{ int retorno = P05.AbrePorta(portaCom, 0, 0, 2); if (retorno == 1) { StringBuilder pesoString = new StringBuilder(); retorno = P05.PegaPeso(1, pesoString, ""); decimal peso = pesoString.ToString().ConvertTo<decimal>(); retorno = P05.FechaPorta(); if(retorno == 1) { return peso; } else { //Erro ao fechar porta } } else { //Erro ao abrir a porta } return 0;
}
private const string LOCAL_ESCRITA = ""; //Diretorio onde será gravado o arquivo. Se vazio significa o diretorio local do programa
private const int OPCAO_ESCRITA = 1; //Disponibilizar em => 0 = Arq Texto, 1 = Área de Transferência
Configurar o uso de memória do SQLServer é bem simples pelo seu gerenciador
No Pesquisador de Objetos, clique com o botão direito do mouse em um servidor e selecione Propriedades.
Clique no nó Memória.
Em Opções de Memória do Servidor, insira a quantidade desejada para Memória mínima do servidor e Memória máxima do servidor.
Mas pode ser interessante setar esta propriedade diretamente com comando.
Obs. os comandos a seguir sempre deve ser executados e depois confirmados com o comando RECONFIGURE.
Primeiro vamos permitir executar comandos com as opções avançadas.
sp_configure 'show advanced options', 1;
RECONFIGURE;
Depois vamos alterar a memória máxima para 1024 MB.
sp_configure 'max server memory', 1024;
RECONFIGURE;
Feito, o SQLServer já está com o valor alterado, caso queira conferir é só ir no mesmo menu descrito acima.
Lembrando que como é um comando T-SQL você pode usá-lo com sua aplicação executando o comando que funcionará,
não precisa necessariamente ser executado do Management Studio.
Certo dia me deparei com a seguinte questão, precisava que meu aplicativo gravasse um arquivo em uma pasta que estava na rede,
mas o usuário logado não tinha permissão de escrita nela, somente de leitura, então o método de gravar arquivo retornava um erro
genérico e não conseguia saber ao certo qual era o problema. Quando fui no servidor conferir vi que aquele usuário daquela máquina
não tinha permissão, então com este método que vou lhes mostrar fica fácil saber que o usuário não tem permissão e é possível
mostrar mais detalhadamente isso ao usuário do aplicativo.
public bool PermissaoEscrita(string diretorio)
{ try { System.Security.AccessControl.FileSystemSecurity security; if (File.Exists(diretorio)) { security = File.GetAccessControl(diretorio); } else { security = Directory.GetAccessControl(diretorio); } var regras = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
var usuarioCorrente = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent()); bool resultado = false; foreach (System.Security.AccessControl.FileSystemAccessRule regra in regras) { if (0 == (regra.FileSystemRights & (System.Security.AccessControl.FileSystemRights.WriteData | System.Security.AccessControl.FileSystemRights.Write))) { continue; }
if (regra.IdentityReference.Value.StartsWith("S-1-")) { var sid = new System.Security.Principal.SecurityIdentifier(regra.IdentityReference.Value); if (!usuarioCorrente.IsInRole(sid)) { continue; } } else { if (!usuarioCorrente.IsInRole(regra.IdentityReference.Value)) { continue; } }
Este método recebe como parâmetro uma string com o caminho do diretorio, verifica se o usuário atual tem permissão de escrita nela e retorna verdadeiro ou falso.
A partir disso pode ser exibida uma mensagem personalizada ao usuário, ou então uma tomada de decisão no código, enfim são várias as possibilidades.
O arquivo de NFP (Nota Fiscal Paulista) tem um padrão de nomenclatura para facilitar a identificação do arquivo sem a necessidade de abri-lo.
Iremos utilizar como exemplo o nome fictício DR200173.18B.
Onde DR indica a marca do ECF, como nos exemplos:
DR - Daruma
BE - Bematech
EL - Elgin
SW - Sweda
200173 indicam uma identificação do ECF (número série).
E agora o foco dessa postagem que é a extensão do arquivo. Ela sempre terá 3 caracteres, onde o primeiro indica o dia, o segundo indica o mês e o terceiro indica o ano.
No nosso exemplo temos 18B, que traduzindo significa dia 1 do mês 8 (agosto) do ano B (2011).
Espere B significa 2011 como isso? Sim pois como só existe um dígito para indicar cada uma das partes da data o que acontece quando o valor passa de 9, não podemos colocar 10 pois ocuparia dois dígitos, então é substituído por letras começando do A, por isso B no espaço do ano significa 2011, pois B significa 11.
Vamos para outros exemplos:
37D - traduzindo significa dia três, do mês sete (julho), do ano treze (2013).
EAF - dia quatorze de outubro de 2015
V8F - 31/08/2015
Vou deixar uma tabela para facilitar o trabalho de vocês na hora de traduzir a extensão.
A = 10 M = 22
B = 11 N = 23
C = 12 O = 24
D = 13 P = 25
E = 14 Q = 26
F = 15 R = 27
G = 16 S = 28
H = 17 T = 29
I = 18 U = 30
J = 19 V = 31
K = 20
L = 21
Quando estamos executando algum método, consulta ou algo que demore a retornar é possível que o usuário tecle ou clique em algo que atrapalhe a execução.
Aqui irei mostrar uma das formas de bloquear o mouse e o teclado do usuário na aplicação enquanto ela executa alguma função.
Utilizaremos o método BlockInput que está na USER32, então teremos que importá-lo, ele não retorna nenhuma valor e recebe como parâmetro um boleano indicando bloqueio quando true e desbloqueio quando false, como segue abaixo.
[DllImport("USER32.DLL")]
public static extern void BlockInput(bool block);
Feito isso é só chamar este método passando o parâmetro boleano true quando quiser bloquear e passar o parâmetro false quando quiser desbloquear.
Veja no exemplo.
Pronto enquanto eu executo o método de pesquisa de clientes no banco através do CPF o teclado e o mouse do usuário ficarão bloqueados na aplicação.
Obs. O usuário ainda poderá utilizar algumas funções do teclado como pressionar Ctrl + Alt + Del por exemplo.
Com esta dica ficará fácil saber quais portas com estão instaladas no computador. Existem várias aplicações possíveis para a necessidade de saber se tal porta com existe
ou ter um retorno de todas as que estão instaladas atualmente no computador como por exemplo ao tentar comunicar com uma impressora não fiscal instalada em uma porta COM.
Imagine que tenho COM1 e COM2 no meu computador, mas o usuário do sistema o configurou erroneamente na COM3, sabendo que a COM3 se quer existe no computador, nem preciso
testar a comunicação posso retornar um erro diretamente ao usuário de uma forma mais rápida.
Vamos ao código.
Primeiramente irei declarar a System.IO.Ports, pois ela contém o método que iremos utilizar.
using System.IO.Ports
Agora vou criar um método que recebe como parâmetro a porta COM que desejo utilizar e retorna um boleano para saber se a porta existe.
public bool VerificaPortaCom(string portaCOM)
{ string[] portasInstaladas = SerialPort.GetPortNames();
if (portasInstaladas.Any(x => x.Equals(portaCOM))) //procura no vetor se existe alguma string com o conteúdo igual ao da variável portaCOM { retur true; } else { retur false; }
}
Pronto o retorno do método já me indicará se a porta passada como parâmetro existe ou não, bem simples.
string porta = "COM2"
if(VerificaPortaCom(porta))
{ ComunicarImpressoraNaoFiscal(porta); }
else
{ ExibeTelaErro("Porta " + porta + " não existe") }
Algumas vezes pode ser interessante chamar a atenção do usuário, seja por uma validação de campo, mensagem de aviso ou de erro na aplicação.
Para irei demonstrar a utilização de beeps do windows sendo chamados via programação.
A primeira coisa a fazer é importar o método nativo de Beep que está na DLL kernel32. Ele tem dois parâmetros um para a frequência do beep,
ou seja, se ele será mais grave, mais agudo, enfim definir a frequência sonora dele, o outro parâmetro é para indicar o tempo de duração
deste beep.
[DllImport("kernel32.dll")]
public static extern bool Beep(int frequencia, int duracao);
Alguns exemplos de utilização deste método:
Beep(800, 100);
Beep(670, 75);
Beep(930, 260);
if(ExisteCampoEmBranco)
{ Beep(800, 100); ExibeTelaErro("Favor preencher todos os campos");
}
Esta dica é de como executar algum comando no cmd do windows direto com programação em C#.
De forma bem simples você pode criar um método que chame este comando, que é o único necessário para abrir, executar e fechar o cmd.
//declarando uma string com o comando somente para facilitar a visualização
string executar = @"/C " + "comando que deseja executar no cmd";
//Executa o comando no cmd do windows e aguarda a execução do mesmo para fechá-lo
System.Diagnostics.Process.Start("CMD.exe", executar).WaitForExit();
Imagine que quero que a minha aplicação crie uma pasta pelo prompt meu método ficaria com estas linhas:
A dica de hoje é sobre organização.
Algumas vezes utilizamos DLLs externas em nossas aplicações e organizá-las em pastas pode ser uma boa ideia. Para isso existe uma forma simples em C# para setar o caminho onde a DLL desejada está e com isso a aplicação à chamar sem maiores problemas.
O método utilizado será o SetCurrentDirectory que está em System.IO.Directory.
Vamos ao exemplo comentado:
string current = Directory.GetCurrentDirectory(); //serve para saber qual é o diretório corrente
string caminho = @"\DLLs"; //Indica o caminho para localizar a dll em questão
Directory.SetCurrentDirectory(current + caminho);
Com isso é setado como diretório corrente "diretório da sua aplicação\DLLs", com a DLL nesta pasta primeiramente o windows procurará nela, depois na pasta do aplicativo e por fim na pasta system32. Então qualquer informação ou execução de métodos poderá ser realizado nesta DLL da pasta "\DLLs "
Feito isso você deverá voltar o diretório corrente para o diretório da aplicação, o que também é bastante simples veja:
current = Directory.GetCurrentDirectory().Replace(caminho, ""); //seleciona o caminho raiz da aplicação
Directory.SetCurrentDirectory(current); //seta o diretório como corrente para a aplicação continuar a sua execução normalmente
Postagens
