Descubra uma ampla variedade de tópicos de referência na Biblioteca MSDN para Visual C# 2010.
Explore os recursos novos e aprimorados do Visual C# 2010. Eles trabalham juntos para melhorar a capacidade de programação do Microsoft Office, aumentar sua habilidade em explorar códigos, fornecer suporte ao desenvolvimento orientado a testes e mais.
Para ver tudo isso clique aqui.
07
Dez
09
Tudo sobre o C# 2010
Dois anos após chegar oficialmente ao País, console tem preços cortados para aproveitar vendas Natal em pacote com dois jogos, cabo HDMI e HD de 60 GB.
A Microsoft anuncia nesta terça-feira (1/12) corte no preço do seu console Xbox 360, que passa a chegar às prateleiras brasileiras por 1.499 reais, queda em relação aos 1.799 reais sugeridos anteriormente.
Segundo o gerente de marketing de Xbox 360 no Brasil, Guilherme Carmargo, o corte é justificado pela proximidade com o Natal e, segundo estimativas da empresa, deverá causar um aumento de 30% nas vendas do aparelho na comparação com novembro.
O pacote do Xbox 360 conta com dois jogos incluídos (“Too Human” e “Project Gotham Racing 4″), um controle, disco rígido de 60 GB e cabo HDMI, o que permite que partidas seja jogadas em alta definição em TVs que suportem o sistema.
O corte acontece dois anos após a Microsoft introduzir oficialmente o Xbox 360 no Brasil. O primeiro pacote do console era oferta por 3 mil reais, dobro do preço atual sugerido pela fabricante.
Segundo Camargo, o câmbio favorável e a otimização de custos na cadeia nacional de importação do console ajudaram na queda do seu preço.
Nestes dois anos em que o Xbox 360 está oficialmente no mercado brasileiro, a Microsoft estima que entre 10% e 15% dos consoles no Brasil tenham sido comprados no varejo nacional.
A quantia restante diz respeito tanto a consoles comprados no Brasil fora do pacote ofertado oficialmente pela Microsoft como a aparelhos trazidos de outros mercados.
Atualmente, a Microsoft oferece 26 jogos para Xbox 360 no mercado brasileiro com manual em português e classificação etária. Alguns dos títulos contam com dublagem em português, como é o caso de “Halo 3″ e “Viva Piñata”.
O corte acontece pouco mais de uma semana depois da Sony ter começado a vender oficialmente a linha Playstation no Brasil, por meio do seu site Sony Style.
Lançado originalmente em 2000, o console Playstation 2 é ofertado por 799 reais, com jogos que custam 99 reais.
Rival direto do Xbox 360, o Playstation 3 ainda não está disponível oficialmente pela fabricante, muito embora títulos para o console sejam ofertados a preços que variam entre 199 reais e 249 reais.
Fonte: Portal XBox
Alterna o contexto de execução de volta para o chamador da última instrução EXECUTE AS.
REVERT pode ser especificado dentro de um módulo como um procedimento armazenado ou uma função definida pelo usuário, ou como uma instrução autônoma. Quando especificado dentro de um módulo, REVERT só é aplicável às instruções EXECUTE AS definidas no módulo. Por exemplo, o procedimento armazenado a seguir emite uma instrução EXECUTE AS seguida por uma instrução REVERT.
Exemplo
CREATE PROCEDURE dbo.usp_myproc
WITH EXECUTE AS CALLER
AS
SELECT SUSER_NAME(), USER_NAME();
EXECUTE AS USER = ‘guest’;
SELECT SUSER_NAME(), USER_NAME();
REVERT;
SELECT SUSER_NAME(), USER_NAME();
GO
Usando REVERT WITH COOKIE
A instrução EXECUTE AS usada para definir o contexto de execução de uma sessão pode incluir a cláusula opcional WITH NO REVERT COOKIE = @varbinary_variable. Quando essa instrução é executada, Mecanismo de Banco de Dados passa o cookie para @varbinary_variable. O contexto de execução definido por essa instrução só pode ser revertido para o contexto anterior se a declaração de chamada REVERT WITH COOKIE = @varbinary_variable tiver o valor @varbinary_variable correto.Esse mecanismo é útil em um ambiente no qual o pool de conexões é usado. O pool de conexões é a manutenção de um grupo de conexões de banco de dados para ser reutilizado nos aplicativos por vários usuários finais. Como o valor passado para @varbinary_variable é conhecido apenas pelo chamador da instrução EXECUTE AS (no caso, o aplicativo), o chamador pode garantir que o contexto de execução estabelecido não possa ser alterado pelo usuário final que invocar o aplicativo. Depois que o contexto de execução é revertido, o aplicativo pode alterná-lo para outra entidade. Exemplos Usando EXECUTE AS e REVERT para alternar o contextoO exemplo a seguir cria uma pilha de execução de contexto usando várias entidades. A instrução REVERT é usada para redefinir o contexto de execução para o chamador anterior. A instrução REVERT é executada várias vezes movendo a pilha para cima até o contexto de execução ser definido como o chamador original.
USE AdventureWorks;
GO
– Create two temporary principals.
CREATE LOGIN login1 WITH PASSWORD = ‘J345#$)thb’;
CREATE LOGIN login2 WITH PASSWORD = ‘Uor80$23b’;
GO
CREATE USER user1 FOR LOGIN login1;
CREATE USER user2 FOR LOGIN login2;
GO
– Give IMPERSONATE permissions on user2 to user1
– so that user1 can successfully set the execution context to user2.
GRANT IMPERSONATE ON USER:: user2 TO user1;
GO
– Display current execution context.
SELECT SUSER_NAME(), USER_NAME();
– Set the execution context to login1.
EXECUTE AS LOGIN = ‘login1′;
– Verify that the execution context is now login1.
SELECT SUSER_NAME(), USER_NAME();
– Login1 sets the execution context to login2.
EXECUTE AS USER = ‘user2′;
– Display current execution context.
SELECT SUSER_NAME(), USER_NAME();
– The execution context stack now has three principals: the originating caller, login1, and login2.
– The following REVERT statements will reset the execution context to the previous context.
REVERT;
– Display the current execution context.
SELECT SUSER_NAME(), USER_NAME();
REVERT;
– Display the current execution context.
SELECT SUSER_NAME(), USER_NAME();
– Remove the temporary principals.
DROP LOGIN login1;
DROP LOGIN login2;
DROP USER user1;
DROP USER user2;
GO
Usando a cláusula WITH COOKIE
O exemplo a seguir define o contexto de execução de uma sessão para um usuário determinado e especifica a cláusula WITH NO REVERT COOKIE = @varbinary_variable. A instrução REVERT deve especificar o valor passado para a variável @cookie na instrução EXECUTE AS para reverter com êxito o contexto de volta para o chamador. DECLARE @cookie varbinary(100);
EXECUTE AS USER = ‘user1′ WITH COOKIE INTO @cookie;
– Store the cookie somewhere safe in your application.
– Verify the context switch.
SELECT SUSER_NAME(), USER_NAME();
–Display the cookie value.
SELECT @cookie;
GO
– Use the cookie in the REVERT statement.
DECLARE @cookie varbinary(100);
– Set the cookie value to the one from the SELECT @cookie statement.
SET @cookie = ;
REVERT WITH COOKIE = @cookie;
– Verify the context switch reverted.
SELECT SUSER_NAME(), USER_NAME();
GO
Para ver o artigo original clique aqui.
Aprenda a trabalhar com o Visual Studio Team Foundation clicando no link abaixo.
patterns & practices Team Development with TFS Guide (Final Release)
Por Mauricio Medina
Venho falando em todos os meus últimos artigos sobre transações, um conceito que para muitos ainda é meio complicado, e para os envolvidos em projetos e com aplicações com problemas sempre é um desafio.
Minha experiência vem da minha vida dentro de vários clientes, onde, independentemente do nível de maturidade, processos e etc, sempre sofrem uma pressão enorme para que os projetos entrem na data, as aplicações funcionem minimamente e vai por ai.
Como tenho clientes com um diversidade enorme de maturidade em relação à processos, métodos, automação e etc., sempre busco entender qual o nível mais adequado para cada um deles, e tentar traduzir isto em algo que realmente funcione dentro das limitações e capacidades de cada um.
Hoje
Na maior parte das grandes corporações, há uma terceirização forte quanto ao desenvolvimento de aplicações, tanto na contratação do desenvolvimento externo, quanto no uso de desenvolvedores externos dentro do seu ambiente, seguindo seus métodos e processos. E sempre vejo que de alguma forma, muitos testes são negligenciados por inúmeros problemas que tenho certeza que o leitor deve ter alguma experiência. Mas a pressão continua, e a responsabilidade por garantir que vai funcionar a contento também.
Tem muito do eu ganho, nós empatamos e vocês perdem nestes casos. A pressão para seguir cronogramas faz com que mesmo as empresas que investiram rios de dinheiro em processos, métodos de desenvolvimento, os ponham de lado em nome da velocidade (time to the market) na entrega das aplicações.
Nos pequenos, processos e métodos são abstrações boas para a hora do almoço ou do chopp de fim de tarde. A pressão que aceitam de seus clientes praticamente os empurra para um desenvolvimento sem um mínimo de testes que não os funcionais, mesmo assim no caminho feliz.
Obviamente há honrosas exceções, mas mesmo estas também costumam ser “flexíveis” quanto a pressão de cada projeto.
E só falei de projetos de desenvolvimento, não disse nada em relação às aplicações mancas, com problemas que devem vir das suas especificações, arquitetura, qualidade de código e vai por ai. E é muito mais fácil pedir mais hardware do que procurar as raízes dos problemas, até porque não se confia na documentação quando existe e código é terra onde ninguém pisa…sabe-se lá como foi feito…
Sempre é mais fácil pedir aumento de hardware, mesmo que ele mostre depois que teve um efeito placebo na performance da aplicação. Mas ai já passou um tempo e a pressão diminuiu um pouco.
Falei numa das minhas últimas matérias sobre a abordagem das transações, e tenho implementado esta abordagem em vários clientes com sucesso.
Mudando o foco
Não quero subverter a ordem dos processos de desenvolvimento e testes de software, mas tenho que admitir que hoje eles estão um pouco longe de estar de fato implementados. Mesmo empresas que receberam algumas certificações abrem mão disto quando se trata de atender às necessidades prementes dos clientes, fazendo a versão com ou sem processo, similar a com ou sem NF.
Minha intenção com esta nova abordagem é mostrar o quanto é mais rápido e barato focar onde realmente interessa para a aplicação e o negócio, em vez de testar toda a aplicação e não se testar nada direito. E tudo que está escrito aqui é totalmente “process agnostic” e pode ser aplicado juntamente com os processos que as empresas já usam.
O foco que proponho é que olhemos a aplicação e identifiquemos quais as transações que mais a influenciam em relação a quantidade de transações, prioridades, criticidade, número de usuários e outros fatores que vão ser revelados nesta análise.
A partir desta visão, e como estou escrevendo para a comunidade Microsoft, podemos rastrear e monitorar as transações COM, +COM e .NET com e sem carga, avaliando o comportamento de cada componente da transação. É muito mais simples e direto, focado somente onde o negócio pode ser sensível a problemas e que limita os esforços aonde interessa.
Nada de testar transações que serão usadas poucas vezes ou que não são críticas. Investimento focado, resultado alcançado.
É lógico que é necessário ter automação neste processo, e vocês podem baixar algumas ferramentas para fazer isto de www.xtremesoft.com para COM e +COM e www.avicode.com para as .NET. Vale a pena e vários usuários no Brasil estão usando com muito sucesso, incluindo a própria Microsoft.
Outro ponto interessante é juntar esta monitoração com testes de carga, onde podem ser usadas várias ferramentas para gerar os usuários virtuais e avaliar-se o impacto que eles trazem para a performance dos componentes da transação e para a aplicação em si. Tentem www.cloudtest.com e vejam como é simples.
Um benefício adicional é que se fizermos uma avaliação ou teste básico (baseline) no ambiente de homologação ou testes, vamos obter algumas métricas que podem ser usadas para pensar se aquela aplicação vai poder conviver em um servidor que já suporta outras aplicaçoes concorrendo pelos mesmos recursos ou se é melhor a instalarmos em outro.
Já testei e implementei esta abordagem em várias situações, sempre com vantagens. E mais, se adicionarmos estes testes com uma análise detalhada do código dos componentes, vamos conseguir melhorar a performance total da aplicação.
Espero que não pareça um chato falando o tempo todo de transações e etc., mas como minha experiência é ditada pelos problemas que encontro nos clientes, sempre busco o caminho mais rápido e barato para ajudá-los.
Fonte: MSDN
A Activision confirmou suas projeções de que “Modern Warfare 2” havia quebrado todos os recordes de estreia durante os cinco primeiros dias de vendas. Segundo a empresa, as vendas do jogo arrecadaram US$ 550 milhões, tornando “Modern Warfare 2” no lançamento mais lucrativo da história, não só dos games, mas de toda a indústria de entretenimento.
A nível de comparação, os maiores lançamentos da indústria literária e cinematográfica, “Harry Potter e o Enigma do Príncipe” e “Batman: O Cavaleiro das Trevas”, arrecadaram respectivamente nos cinco primeiros dias de estreia US$ 394 milhões e US$ 203.8 milhões. O antigo recorde dos videogames pertencia à “Grand Theft Auto 4”, que vendeu 6 milhões de unidades nos cinco primeiros dias de lançamento, totalizando US$ 500 milhões.
Já os jogadores de “Modern Warfare 2” conseguiram estabelecer um novo recorde de jogabilidade na Xbox Live no dia de lançamento do jogo: foram mais de 2,2 milhões de pessoas online.
Mais de 5,2 milhões de horas em sessões multiplayer do jogo foram registradas apenas no primeiro dia, com 11 milhões de conquistas sendo destravadas 24 horas após o lançamento.
Fonte: Portal XBox
20
Nov
09
Formatando Strings no C#
Introdução
A plataforma .NET possui uma série de recursos para manipulação e formatação de strings. Uma dúvida muito comum entre os desenvolvedores é como formatar uma data com hora, sem hora, como formatar números com valor de moeda, com casas decimais, com separador de milhar, etc. A seguir vou apresentar alguns modelos disponíveis que podem ser utilizados para formatação.
String.Format
O modelo de formatação do .NET se baseia na função Format da classe string. Esta função aceita um parâmetro que representa a string que utilizaremos como formato e um array de parâmetros, com os parâmetros que completaram a strings. Array de parâmetros !? Completar a String !? Vamos com calma…
Quando chamamos o método Format, devemos passar uma string que representa o formato final que queremos obter. Esta string deve conter tokens que serão substituidos pelos parâmetros passados no array de parâmetros (a partir do segundo parâmetros). Estes tokens são representados entre chaves { }.
Desta forma, no código representado a seguir….
string sTeste = String.Format(“Vou colocar o {0} aqui.”, “parâmetro”)
// Vou colocar o parâmetro aqui.
… o token representado pelo {0} será substituido pelo primeiro parâmetro passado para a função, no caso a string “parâmetro”.
O número representado dentro do token representa qual dos parâmetros passados para a função será substituido. Podemos utilizar mais de um parâmetro, passando token com como {0}, {1}, {2}, dependendo do número de parâmetros que temos.
No exemplo a seguir, utilizamos dois parâmetros para formatar a string. Note que os parâmetros são de tipos de dados diferentes (inteiro, data e double)
sTeste = String.Format(“Formatação de string com {0} parâmetro. ” +
“Agora são {1}. Valor numérico: {2}”, 1, Now(), 15.5);
Formatando dados string
Para formatar strings, devemos especificar o tipo de dados string no item de formatação. Podemos fazer isto indicando a letra “S” logo após o número do parâmetro dentro do token. Conforme o exemplo a seguir.
sTeste = String.Format(“Este é um teste de formatação {0:S}.”, “teste”);
Além de especificarmos o tipo de dados, podemos especificar o tamanho da string. Neste caso, se informarmos uma string menor do que o tamanho informado, ela será completada com brancos a direita do parãmetro. Coforme o exemplo a seguir.
sTeste = String.Format(“Este é um teste de formatação {0,15:S}, segundo {1:S}.”,
“teste”, “parâmetro”;
// Resulto: Este é um teste de formatação teste , segundo parâmetro.
Se quisermos completar a string com brancos a esquerda, utilizamos um valor negativo no parâmetros, conforme o exemplo a seguir.
sTeste = String.Format(“Este é um teste de formatação {0,-15:S}, segundo {1:S}.”, +
“teste”, “parâmetro”)
// Resulto: Este é um teste de formatação teste, segundo parâmetro.
Formatando números
Da mesma forma que especificamos a letra “S” como tipo de dado “String”, temos tr~es letras que representam dados numéricos. A letra “D”, para números inteiros, e a letra “F” para números decimais fixos e a letra “N” para numeros decimais variáveis. Um exemplo de formatação de uma string com um número inteiro pode ser observado a seguir.
sTeste = String.Format(“Formatação do número inteiro: {0:D}.”, iNumero);
//Formatação do número inteiro: 10.
Da mesma forma que o string, se quisermos completar com espaços em branco (a direita ou a esquerda) um número, podemos indicar o tamanho ao lado do número que representa o token, conforme o exemplo a seguir.
sTeste = String.Format(“Formatação do número inteiro: {0,5:D}.”, iNumero);
sTeste = String.Format(“Formatação do número inteiro: {0,-5:D}.”, iNumero);
//Formatação do número inteiro: 10.
//Formatação do número inteiro: 10 .
No caso de números inteiros, podemos especificar o número de dígitos que o número terá. Para isto podemos informar o número de dígitos após a letra “D”. Desta forma, o comando format completará a string com zero, conforme o tamanho especificado. O exemplo abaixo apresenta este exemplo.
sTeste = String.Format(“Formatação do número inteiro: {0:D4}.”, iNumero);
sTeste = String.Format(“Formatação do número inteiro: {0,-5:D3}.”, iNumero);
// Formatação do número inteiro: 0010.
// Formatação do número inteiro: 010 .
Outro token de formatação que podemos utilizar para valores numéricos é o “F”. O “F” representa um número com casas decimais, e possui uma representação semelhante ao “D”, com a diferença que o número colocado após o “F” representa o número de casas decimais, e não o tamanho da parte inteira, Conforme o exemplo a seguir.
sTeste = String.Format(“Formatação do número decimal: {0:F}.”, nDecimal);
sTeste = String.Format(“Formatação do número decimal: {0:F4}.”, nDecimal);
sTeste = String.Format(“Formatação do número decimal: {0:F8}.”, nDecimal);
//Formatação do número decimal: 15,56.
//Formatação do número decimal: 15,5550.
//Formatação do número decimal: 15,55500000.
Você deve ter percebido que no exemplo anterior o formatador não colocou um separador de milhar para o número, apresentando o número como 15000,75. Se quiseremos utilizar o separados de milhar, não devemos utilizar o formatador “F” e sim o formatador “N”. A única diferença entre os dois é que um utiliza o separados de milhar e o outro não. Podemos constatar isto no exemplo a seguir.
sTeste = String.Format(“Formatação usando numeric: {0:N2}.”,
nDecimal * iNumero * 15);
//Formatação usando numeric: 2.333,25.
O formato monetário
Além dos formatos numéricos convencionais, podemos utilizar o formato monetário para formatar o string. O formato monetário é representado pela letra “C”, conforme o exemplo a seguir.
double nMoeda = 123456.78;
sTeste = String.Format(“Formatação do número monetário: {0:C}.”, nMoeda);
//Formatação do número monetário: R$ 123.456,78.
Note que o valor apresentado no exemplo anterior contém informações relativas a moeda. Se suas configurações regionais estiverem setadas para o Brasil, o número deve ter aparecido com “R$” na frente. Podemos informar uma outra cultura para formatação, bastanto para isto informar um novo parâmetro para a função Format, o parâmetro CultureInfo. Neste parâmetro devemos criar uma instancia da classe CultureInfo, que representa uma informação de regionalização especifica. Esta informação pode ser passada por parâmetro no construtor da classe CultureInfo, conforme o exemplo a seguir.
CultureInfo oCulture = new System.Globalization.CultureInfo(“en-US”);
sTeste = String.Format(oCulture, “Formatação do número inteiro: {0:C}.”, nMoeda);
// Formatação do número inteiro: $123,456.78.
Percentual
Outra opção que temos é formatar o número como percentual, utilizando o token “P”. Neste caso, o número é múltiplicado por 100 e exibido na tela. É possível especificar o número de casas decimais apresentadas no percentual colocando ao lado do token “P” um número, conforme o exemplo a seguir.
sTeste = String.Format(“Formatação do número percentual: {0:P}.”,
nDecimal / iNumero);
Console.WriteLine(sTeste);
sTeste = String.Format(“Formatação do número percentual: {0:P4}.”,
nDecimal / iNumero);
//Formatação do número percentual: 155,55%.
//Formatação do número percentual: 155,5500%.
Hexadecimal
Também é possível converter número para uma representação hexadecimal. Para isso, utilizaremos o token “X”. Da mesma forma que os demais formatadores, podemos especificar o tamanho do valor após a letra X, e com isso completar o valor com zeros a esquerda. O exemplo a seguir mostra uma formatação em hexadecimal.
//*** HexaDecimal
sTeste = String.Format(“Formatação do número hexa: {0:X}.”, iNumero);
Console.WriteLine(sTeste);
sTeste = String.Format(“Formatação do número hexa: {0:X10}.”, iNumero);
Console.WriteLine(sTeste);
//Formatação do número hexa: A.
//Formatação do número hexa: 000000000A.
Formatando Datas
Dentre os tipos disponíveis para formatação, a data é o tipo com mais opções. Existem duas maneiras de se formatar datas: utilizando os formatdos padrão, e utilização formatação customizada. Para utilizar um dos formatos padrão, basta informar uma variável Date como parâmetro e informar um dos tokens disponíveis para formatação. O exemplo a seguir mostra alguns dos tokens disponíveis.
//’*** Formatando Data
DateTime dtHoje = System.DateTime.Now;
sTeste = String.Format(“A data de hoje é: {0:D}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A data de hoje é: {0:d}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A hora atual é: {0:T}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A hora atual é: {0:t}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A data/hora atual é: {0:F}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A data/hora atual é: {0:f}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A data/hora atual é: {0:G}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“A data/hora atual é: {0:g}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“O dia/mês atual é: {0:M}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“Data Ordenavel: {0:s}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“Data Culture Universal: {0:U}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“Mês/Ano: {0:Y}”, dtHoje);
Console.WriteLine(sTeste);
/*
Formatação do número percentual: 155,55%.
Formatação do número hexa: A.
Formatação do número hexa: 000000000A.
A data de hoje é: quarta-feira, 26 de dezembro de 2007
A data de hoje é: 26/12/2007
A hora atual é: 22:01:45
A hora atual é: 22:01
A data/hora atual é: quarta-feira, 26 de dezembro de 2007 22:01:45
A data/hora atual é: quarta-feira, 26 de dezembro de 2007 22:01
A data/hora atual é: 26/12/2007 22:01:45
A data/hora atual é: 26/12/2007 22:01
O dia/mês atual é: 26 de dezembro
Data Ordenavel: 2007-12-26T22:01:45
Data Culture Universal: quinta-feira, 27 de dezembro de 2007 01:01:45
Mês/Ano: dezembro de 2007
*/
Além dos formatos pré-definidos, podemos utilizar o formato customizado. Neste caso devemos dispor os tokens dd, MM, yyyy, HH, mm, ss que representam dia, mês, ano, hora, minuto e segundo respectivamente, da forma mais adequada para nossa situação. MUITO CUIDADO ! O .NET faz diferença entre letras maíusculas e minúsculas. O MM maiúsculo representa meses, e mm minúsculo representa minutos. Outra diferença é em relação a horas, onde HH representa horas com 24 horas, e hh representa horas de 12 em 12 com AM/PM. O exemplo a seguir mostra este tipo de formatação.
sTeste = String.Format(“Custom Format: {0:dd/MM/yyyy hh:mm:ss}”, dtHoje);
Console.WriteLine(sTeste);
sTeste = String.Format(“Custom Format: {0:d/M/yyy HH:mm:ss}”, dtHoje);
Console.WriteLine(sTeste);
//Custom Format: 26/12/2007 10:03:38
//Custom Format: 26/12/2007 22:03:38
Para encerra este assunto, conforme prometido na semana passada, vou postar um tutorial para atualização do drive BENQ do XBox 360.
Clique aqui para baixar o tutorial.
Conforme comentei na semana passada, estou disponibilizando um tutorial muito bem explicado e com muitas fotos de como desmontar o seu XBox 360.
Clique aqui para baixar o tutorial.
12
Nov
09
Formatar CPF e CNPJ – C#
///
/// formata um valor sobre uma mascara
///
/// valor a formatar
/// no formato ex.:##/##/#### ou ##.###,##
/// valor formatado
public static string Formatar( string valor, string mascara )
{
StringBuilder dado = new StringBuilder();
// remove caracteres nao numericos
foreach ( char c in valor )
{
if ( Char.IsNumber(c) )
dado.Append(c);
}
int indMascara = mascara.Length;
int indCampo = dado.Length;
for (; indCampo > 0 && indMascara > 0; )
{
if ( mascara[--indMascara] == ‘#’ )
indCampo–;
}
StringBuilder saida = new StringBuilder();
for (; indMascara < mascara.Length; indMascara++)
{
saida.Append( ( mascara[indMascara] == '#' ) ? dado[indCampo++] : mascara[indMascara] );
}
return saida.ToString();
}
///
/// Formata o CPF para o padrão ###.###.###-##
///
/// CPF a ser formatado
/// Retorna o CPF formatado
public static string FormatarCpf(string cpf)
{
cpf = cpf.Replace(“-”, “”).Replace(“/”, “”).Replace(“.”, “”);
return Formatar(cpf, “###.###.###-##”);
}
///
/// Formata o CNPJ para o padrão ##.###.###/####-##
///
/// CNPJ a ser formatado
/// Retorna o CNPJ formatado
public static string FormatarCnpj(string cnpj)
{
cnpj = cnpj.Replace(“-”, “”).Replace(“/”, “”).Replace(“.”, “”);
return Formatar(cnpj, “##.###.###/####-##”);
}
