Image Image Image Image Image
Scroll to Top

Topo

c#net

20

nov
2011

Sem Comentários

Em Blog

Por Allison

Incorporando funções nativas do Windows em seu projeto .NET

Em 20, nov 2011 | Sem Comentários | Em Blog | Por Allison

Hoje gostaria de mostrar como importar algumas funções nativas do Windows em seu aplicativo usando C#.NET e mostrar como utilizar using de maneira diferente.

Muitas pessoas precisam acessar funções nativas do sistema operacional Windows e para isso é necessário fazer algumas importações acima do método. Mas antes de começar a mostrar, é necessário usar algumas classes do Framework.NET.

using System;
using System.Globalization;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Text;

Junto desses “using” descritos acima, existe uma maneira nova de criar variável local que assume os dados da classe. Primeiro se coloca o nome igualando ao da classe que deseja usar:

using SysComTypes = System.Runtime.InteropServices.ComTypes;

Note que a classe de System.Runtime.InteropServices.ComTypes foi atribuída para a variável SysComTypes. Essa variável pode ser usada dentro da classe em qualquer lugar. É uma maneira interessante para uso de variáveis locais.

Passando agora para a parte de importação nativa do sistema operacional, você precisa colocar no mínimo três linhas de código para cada importação dependendo do método. Em exemplo, para verificar se o login do usuário precisa do código abaixo:

//
// advapi32.dll
//
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool LogonUser(string lpszUsername, string lpszDomain, string lpszPassword, LogOnType dwLogonType, LogOnProvider dwLogonProvider, out IntPtr phToken);
[DllImport("advapi32", CharSet = CharSet.Unicode, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool LogonUser(string lpszUsername, string lpszDomain, IntPtr lpszPassword, LogOnType dwLogonType, LogOnProvider dwLogonProvider, out IntPtr phToken);

A dll nativa é a advapi32 do Windows. Existem outras interfaces disponíveis dessa dll, porém não são muito utilizadas.

Para a dll kernel32 existem outros métodos específicos como pegar a informação do HD local, verificar o status da thread, encontrar arquivo, pegar a memória da máquina e muito mais. Veja alguns exemplos abaixo:

 
//
// kernel32.dll
//
[DllImport("kernel32", BestFitMapping = false, CharSet = CharSet.Unicode, SetLastError = true, ThrowOnUnmappableChar = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool GetVolumeInformation(string lpRootPathName, StringBuilder lpVolumeNameBuffer, int nVolumeNameSize, out int lpVolumeSerialNumber, out int lpMaximumComponentLength, out int lpFileSystemFlags, StringBuilder lpFileSystemNameBuffer, int nFileSystemNameSize);
[DllImport("kernel32", SetLastError = true)]
internal static extern ExecutionState SetThreadExecutionState(ExecutionState esFlags);
[DllImport("kernel32", BestFitMapping = false, CharSet = CharSet.Auto, SetLastError = true, ThrowOnUnmappableChar = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool FindNextFile(SafeFindFileHandle hndFindFile, [In, Out] FindData lpFindFileData);
[DllImport("kernel32", CharSet = CharSet.Auto, SetLastError = true)]
internal static extern void GlobalMemoryStatus(NativeMemoryStatus lpBuffer);
[DllImport("kernel32", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern bool GlobalMemoryStatusEx(NativeMemoryStatusEx lpBuffer);

Bom, o objetivo foi mostrar apenas como colocar a chamada de funções ou métodos nativos do sistema operacional. Em um próximo artigo posso mostrar como usar esses métodos específicos.

Além dessas dlls, existem outras como oleaut32, setupapi, shell32, shlwapi e ole32.dll. Todas essas existem métodos próprios para uso na linguagem C#.NET ou qualquer outra do framework .NET.

Espero que tenha gostado e qualquer dúvida pode entrar em contato pelo site.

Fonte: Maurício Júnor/IMasters

Tags | , , ,

10

out
2011

Sem Comentários

Em Blog

Por Allison

MonoDevelop 2.8 para C# e .NET está disponível para desenvolvedores

Em 10, out 2011 | Sem Comentários | Em Blog | Por Allison

A equipe do MonoDevelop liberou a versão 2.8 de seu IDE (Integrated Development Environment) open source para programação em C# e em outras linguagens .NET. Além de trazer mudanças no editor do código-fonte e novas funções para gerenciamento de projeto, o MonoDevelop 2.8 vem principalmente com mudanças para desenvolvedores Mac.

No Mac OS X, o MonoDevelop adiciona suporte para Xcode 4 e integra o serviço de testes do iOS TestFlight. Os pacotes para o MonoTouch e SDK do iOS agora podem ser configurados individualmente. Também há novos modelos de projetos para as plataformas iPad e iPhone, junto com suporte para iOS 5 Storyboards com o objetivo de facilitar o controle de visualização para desenvolvedores de aplicativos.

Além disso, a nova versão vem com um novo editor para criar esquemas de cores para destaque de sintaxe, junto com um novo esquema de cores padrão. Para o gerenciamento de projeto, o IDE possui um novo diálogo Edit References e revisou as visualizações do Class e do Document Outline.

Mais informações sobre a atualização podem ser encontradas nas notas de lançamento. O MonoDevelop 2.8 está disponível para download a partir do site do projeto e do GitHub. O IDE foi feito para assegurar que um base de código unificada ao portar aplicativos .NET criados com Visual Studio para Linux e para Mac OS X.

Texto publicado originalmente no The H

Fonte: IMaster

Tags | , , , , , ,

16

set
2011

Sem Comentários

Em Blog

Por Allison

Java 8: Sintaxe de expressões Lambda será baseada em sintaxes de C# e Scala

Em 16, set 2011 | Sem Comentários | Em Blog | Por Allison

Uma das funcionalidades mais aguardadas do Java 8 é a introdução de lambdas: funções anônimas que podem ser passadas como argumentos ou atribuídas a variáveis. Entretanto a sintaxe ainda estava em discussão, sendo inclusive feito uma enquete para determinar quais seriam as sintaxes mais populares.

Em uma mensagem recente de Brian Goetz na lista de discussões lambda-dev, foi anunciado que a sintaxe a ser adotada para os Lambdas na linguagem Java será baseada na sintaxe do C#. Pesou na decisão o fato desta sintaxe já ser bem conhecida e usada (o C# usa delegações desde a versão 1.0, tem suporte para funções de delegação na versão 2.0 e expressões lambda na versão 3.0).

Apesar de haver outras alternativas possíveis (tais como o BGGA) as respostas ao enquete levaram a crer que não havia vantagens significativas de nenhuma das sintaxes sobre as demais. Além disso, a experiência anterior dos que já utilizam C# e Scala indica que provavelmente já existem bem mais programadores familiares com este tipo de sintaxe. (A principal diferença entre os estilos de declaração de funções anônimas em C# e Scala é na forma como os tipos dos argumentos são indicados; C# usa “int foo” enquanto Scala usa “foo: int”, uma diferença com que se pode acostumar. Será adotado o estilo do C# devido à sua semelhança com a sintaxe para declaração de tipos de argumentos em Java.

Brian Goetz afirma que:

Apesar da procura extensiva, não houve um vencedor claro entre as alternativas (todas tem alguns aspectos desejáveis e outros não tão desejáveis, e não há nenhuma sintaxe que seja realmente melhor do que as outras). Assim, pensamos que seria melhor escolher algo que já foi comprovado na prática em duas linguagens que são bem semelhantes ao Java: C# e Scala, ao invés de algo totalmente novo.

Serão permitidos o uso de expressões e também de blocos. Uma expressão é representada sem o uso de chaves e devolve um resultado quando avaliada. Blocos serão declarados entre chaves e não devolverão nenhum valor a não ser que a palavra-chave return seja usada. Os seguintes exemplos foram apresentados na lista de discussão:

x => x + 1

(x) => x + 1

(int x) => x + 1

(int x, int y) => x + y

(x, y) => x + y

(x, y) => { System.out.printf("%d + %d = %d%n", x, y, x+y); }

() => { System.out.println("I am a Runnable"); }

Uma grande vantagem das expressões lambda é a capacidade de inferir tipos de argumentos, caso estes não estejam especificados explicitamente. Em alguns casos, o compilador pode não ser capaz de inferir os tipos corretos. Isso acontece especialmente no caso de operadores sobrecarregados; por exemplo, “(x,y) => x+y” não irá compilar se o Java não tiver informação de que x e y são long ou double (ou até mesmo Object). Na maioria dos casos, o mecanismo de inferência de tipos será capaz de gerar o código correto, mas caso seja necessário um auxílio adicional, o desenvolvedor sempre poderá incluir explicitamente os tipos dos argumentos.

Em breve estará disponível um compilador que reconhece a nova sintaxe, para testes e experimentações.

Fonte: Postado por Alex Blewitt/Traduzido por Wellington Pinheiro/InfoQ

Tags | , , ,

27

ago
2011

Sem Comentários

Em Blog

Por Allison

Dica ASP.NET para alerta e nova página

Em 27, ago 2011 | Sem Comentários | Em Blog | Por Allison

Olá, pessoal, hoje vou falar um pouco das coisas simples, mas que se tornam complicadas quando colocamos o objeto Ajax do .NET na aplicação. Um exemplo disso são as mensagens em javascript, ou as que surgem no momento de abrir um popup. Antes de colocar o objeto <ScriptManager> ou o <ToolkitScriptManager>, todas as mensagens javascript de alerta ou script para abrir popup funcionam sem qualquer problema.

Depois de colocar as tags e usar o <UpdatePanel> e o <ContentTemplate>, aquelas mensagens que funcionam deixam de funcionar apresentando apenas um erro na tela. Todo esse processo é mostrado quando a mensagem javascript está dentro do código VB.NET ou C#.NET.

O objetivo é mostrar uma forma simples e fácil de como deixar funcionando os comandos javascripts dentro do C#.NET.

Usado: Linguagem C#.NET, ferramenta Visual Studio 2010, plataforma ASP.NET (web).

A mensagem deve vir de dentro do código de programação, como na imagem 1. Veja no código 1 como tem que ficar.

Imagem 1

Ao clicar no botão da página aspx, o campo não foi preenchido e, de acordo com a regra do sistema, precisa ser preenchido pelo usuário. Foi usado o ScriptManager.RegisterClientScriptBlock passando alguns parâmetros particulares para exibição da mensagem mantendo ainda os dados da tela aspx.

ScriptManager.RegisterClientScriptBlock(this, this.GetType(),”sua-mensagem”, “alert(‘sua mensagem qualquer’)”, true);

Código 1

Analisando o Código 1, veja que a parte onde fica “sua-mensagem” é apenas um controle, como se fosse um id de objeto de tela, ou seja, não deve ser repetido na mesma página. Não é necessário passar o <script>javascript:</script>, basta colocar o alert ou confirm para quem usa.

Para exibir uma mensagem na tela pegando alguma variável do próprio C#.NET, basta utilizar as aspas e a concatenação:

String situacao = “meu nome”;

ScriptManager.RegisterClientScriptBlock(this, this.GetType(), “mensagem-1”, “alert(‘” + situacao + “‘);”, true);

Código 2

Esse código resolveu o meu problema para exibição de alerta javascript na página. Ele pode resolver o seu também. Finalizando, para abrir outra página executando dentro do código C#.NET, veja o código seguinte:

ScriptManager.RegisterClientScriptBlock(this, this.GetType(), “abrir-1”, “window.open(‘pagina.aspx’)”, true);

Código 3

O Código 3 executa o window.open chamando a página. Em resumo, todo código javascript que quiser colocar dentro do C#.NET pode ser colocado de acordo com os exemplos acima.

Fonte: IMaster

Tags | , , , , ,