<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Tratamento de Data e Hora &#8211; Curso Online de C# .NET</title>
	<atom:link href="//www.tomasvasquez.com.br/cursocsharp/category/tratamento-de-data-e-hora/feed" rel="self" type="application/rss+xml" />
	<link>//www.tomasvasquez.com.br/cursocsharp</link>
	<description>Uma iniciativa de Tomás Vásquez</description>
	<lastBuildDate>Sun, 06 May 2018 04:22:10 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>https://wordpress.org/?v=4.9.8</generator>
	<item>
		<title>Formatos Customizados para o DateTime</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/formatos-customizados-para-o-datetime</link>
		<pubDate>Fri, 18 Sep 2009 18:45:55 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tratamento de Data e Hora]]></category>
		<category><![CDATA[Custom]]></category>
		<category><![CDATA[DateTime]]></category>
		<category><![CDATA[Formatos]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=276</guid>
		<description><![CDATA[O exemplos abaixo mostram as opções de formatação do tipo DateTime do C# utilizando o método String.Format. Estas opções também podem ser aplicadas através do método DateTime.ToString(). Formatos Customizados São disponibilizados os seguintes formatos: y (ano), M (mês), d (dia), h (hora 12), H (hora 24), m (minuto), s (segundo), f (fração de segundo), F &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/formatos-customizados-para-o-datetime" class="more-link">Continue lendo <span class="screen-reader-text">Formatos Customizados para o DateTime</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O exemplos abaixo mostram as opções de formatação do tipo DateTime do C# utilizando o método String.Format. Estas opções também podem ser aplicadas através do método DateTime.ToString().</p>
<h3>Formatos Customizados</h3>
<p>São disponibilizados os seguintes formatos: <strong>y</strong> (ano), <strong>M </strong>(mês), <strong>d </strong>(dia), <strong>h </strong>(hora 12), <strong>H </strong>(hora 24), <strong>m </strong>(minuto), <strong>s </strong>(segundo), <strong>f</strong> (fração de segundo), <strong>F </strong>(fração de segundo com zeros omitidos), <strong>t </strong>(P.M ou A.M) e <strong>z </strong>(fuso horário).</p>
<p>O exemplos abaixo mostram o resultado de datas formatadas utilizando as opções acima:</p>
<pre lang="csharp">// cria um objeto DateTime com o valor 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);

String.Format("{0:y yy yyy yyyy}", dt);  // "8 08 008 2008"   ano
String.Format("{0:M MM MMM MMMM}", dt);  // "3 03 Mar March"  mês
String.Format("{0:d dd ddd dddd}", dt);  // "9 09 Sun Sunday" dia
String.Format("{0:h hh H HH}",     dt);  // "4 04 16 16"      hora 12/24
String.Format("{0:m mm}",          dt);  // "5 05"            minuto
String.Format("{0:s ss}",          dt);  // "7 07"            segundo
String.Format("{0:f ff fff ffff}", dt);  // "1 12 123 1230"   fração de segundo
String.Format("{0:F FF FFF FFFF}", dt);  // "1 12 123 123"    com os zeros omitidos
String.Format("{0:t tt}",          dt);  // "P PM"            A.M. ou P.M.
String.Format("{0:z zz zzz}",      dt);  // "-6 -06 -06:00"   fuso horário</pre>
<p>Também é possível utilizar os separadores de data (/) e hora (:) na string. O padrão sugerido é o inglês, mas estes serão substituídos para o caracterer específico da cultura/idioma configurado no sistema operacional em execução. Estes podem ser obtidos diretamente através das propriedades DateTimeForma­tInfo.DateSepa­rator e DateTimeForma­tInfo.TimeSepa­rator, sob o namespace System.Globalization.</p>
<p>Exemplos:</p>
<pre lang="csharp">// separador de data na cultura alemã é o "."
// (ou seja, este será colocado no lugar no "/")
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - Inglês (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - Alemão (de-DE)</pre>
<p>Outros exemplos de formatos customizados:</p>
<pre lang="csharp">// dia/mês sem e com zeros
String.Format("{0:d/M/yyyy}", dt);            // "9/3/2009"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"

// nomes de dia e mês
String.Format("{0:ddd, MMM d, yyyy}", dt);    // "Dom, Mar 9, 2009"
String.Format("{0:dddd, d de MMMM de yyyy}", dt);  // "Domingo, 9 de Março de 2009"

// ano com 2 e 4 dígitos
String.Format("{0:dd/MM/yy}", dt);            // "09/03/09"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"</pre>
<h3>Formatos Padrozinados para o DateTime</h3>
<p>O <a href="http://msdn2.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx">DateTimeForma­tInfo</a> define formatos padrão para cada região/país. Por exemplo , a propriedade <a href="http://msdn2.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.shorttimepattern.aspx">ShortTimePattern</a> representa uma string que contém o valor <code>h:mm tt</code> para a cultura <strong>en-US</strong> culture, enquanto para a cultura <strong>de-DE </strong>o valor é <code>HH:mm</code>.</p>
<p>A tabela abaixo demonstra o padrões definidos para o tipo <a href="http://msdn2.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx">DateTimeForma­tInfo</a> e seus valores para a cultura en-US, que é a padrão do .NET Framework. A primeira coluna contém os &#8220;especificadores&#8221; para o método <a href="http://msdn2.microsoft.com/en-us/library/system.string.format.aspx">String.Format</a>.</p>
<table border="0">
<tbody>
<tr>
<th>Especificado</th>
<th>Propriededade do DateTimeFormatInfo</th>
<th>Valor padrão (en-US)</th>
</tr>
<tr>
<td><code>t</code></td>
<td>ShortTimePattern</td>
<td><code>h:mm tt</code></td>
</tr>
<tr>
<td><code>d</code></td>
<td>ShortDatePattern</td>
<td><code>M/d/yyyy</code></td>
</tr>
<tr>
<td><code>T</code></td>
<td>LongTimePattern</td>
<td><code>h:mm:ss tt</code></td>
</tr>
<tr>
<td><code>D</code></td>
<td>LongDatePattern</td>
<td><code>dddd, MMMM dd, yyyy</code></td>
</tr>
<tr>
<td><code>f</code></td>
<td><em>(combinação entre <code>D</code> e <code>t</code>)</em></td>
<td><code>dddd, MMMM dd, yyyy h:mm tt</code></td>
</tr>
<tr>
<td><code>F</code></td>
<td>FullDateTimePattern</td>
<td><code>dddd, MMMM dd, yyyy h:mm:ss tt</code></td>
</tr>
<tr>
<td><code>g</code></td>
<td><em>(</em><em>combinação de</em><em> <code>d</code> e <code>t</code>)</em></td>
<td><code>M/d/yyyy h:mm tt</code></td>
</tr>
<tr>
<td><code>G</code></td>
<td><em>(</em><em>combinação de </em><em><code>d</code> e <code>T</code>)</em></td>
<td><code>M/d/yyyy h:mm:ss tt</code></td>
</tr>
<tr>
<td><code>m</code>, <code>M</code></td>
<td>MonthDayPattern</td>
<td><code>MMMM dd</code></td>
</tr>
<tr>
<td><code>y</code>, <code>Y</code></td>
<td>YearMonthPattern</td>
<td><code>MMMM, yyyy</code></td>
</tr>
<tr>
<td><code>r</code>, <code>R</code></td>
<td>RFC1123Pattern</td>
<td><code>ddd, dd MMM yyyy HH':'mm':'ss 'GMT'</code> <em>(*)</em></td>
</tr>
<tr>
<td><code>s</code></td>
<td>SortableDateTi­mePattern</td>
<td><code>yyyy'-'MM'-'dd'T'HH':'mm':'ss</code> <em>(*)</em></td>
</tr>
<tr>
<td><code>u</code></td>
<td>UniversalSorta­bleDateTimePat­tern</td>
<td><code>yyyy'-'MM'-'dd HH':'mm':'ss'Z'</code> <em>(*)</em></td>
</tr>
<tr>
<td></td>
<td></td>
<td><em>(*) = independe da cultura</em></td>
</tr>
</tbody>
</table>
<p>Os exemplos abaixo utilizam os <strong>especificadores padrão de formatação</strong> através do método <a href="http://msdn2.microsoft.com/en-us/library/system.string.format.aspx">String.Format</a> e seus resultados, neste caso, para a cultura en-US. Lembrando que os mesmos especificadores podem ser utilizados com o método <strong>ToString()</strong>.</p>
<pre lang="csharp">String.Format("{0:t}", dt);  // "4:05 PM"                         ShortTime
String.Format("{0:d}", dt);  // "3/9/2008"                        ShortDate
String.Format("{0:T}", dt);  // "4:05:07 PM"                      LongTime
String.Format("{0:D}", dt);  // "Sunday, March 09, 2008"          LongDate
String.Format("{0:f}", dt);  // "Sunday, March 09, 2008 4:05 PM"  LongDate+ShortTime
String.Format("{0:F}", dt);  // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt);  // "3/9/2008 4:05 PM"                ShortDate+ShortTime
String.Format("{0:G}", dt);  // "3/9/2008 4:05:07 PM"             ShortDate+LongTime
String.Format("{0:m}", dt);  // "March 09"                        MonthDay
String.Format("{0:y}", dt);  // "March, 2008"                     YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"   RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"             SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"            UniversalSortableDateTime</pre>
<p>Efetuar os testes acima na cultura brasileira (pt-BR), o resultado será:</p>
<pre lang="csharp">String.Format("{0:t}", dt);  // "16:05"					ShortTime
String.Format("{0:d}", dt);  // "9/3/2008"					ShortDate
String.Format("{0:T}", dt);  // "16:05:07"					LongTime
String.Format("{0:D}", dt);  // "domingo, 9 de março de 2008"		LongDate
String.Format("{0:f}", dt);  // "domingo, 9 de março de 2008 16:05"		LongDate+ShortTime
String.Format("{0:F}", dt);  // "domingo, 9 de março de 2008 16:05:07" 	FullDateTime
String.Format("{0:g}", dt);  // "9/3/2008 16:05"				ShortDate+ShortTime
String.Format("{0:G}", dt);  // "9/3/2008 16:05:07"				ShortDate+LongTime
String.Format("{0:m}", dt);  // "09 de março"				MonthDay
String.Format("{0:y}", dt);  // "março de 2008"				YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"		RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"			SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"			UniversalSortableDateTime</pre>
]]></content:encoded>
			</item>
		<item>
		<title>Conversões de/para string e Formatação</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/conversoes-depara-string-e-formatacao</link>
		<pubDate>Sun, 30 Aug 2009 20:26:03 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tratamento de Data e Hora]]></category>
		<category><![CDATA[Convert]]></category>
		<category><![CDATA[Data]]></category>
		<category><![CDATA[DateTime]]></category>
		<category><![CDATA[Format]]></category>
		<category><![CDATA[Hora]]></category>
		<category><![CDATA[Parse]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=272</guid>
		<description><![CDATA[Classe Convert Podemos usar os métodos da classe Convert para efetuar conversões. Parse/Format Estes são os métodos indicados quando existe intervenção do usuário, pois temos um bom controle de como será feita a conversão. Em ambos os métodos podemos especificar a formatação de duas formas: Indicando a “Culture”. Fornecendo uma string de conversão, como por &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/conversoes-depara-string-e-formatacao" class="more-link">Continue lendo <span class="screen-reader-text">Conversões de/para string e Formatação</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<h3>Classe Convert</h3>
<p>Podemos usar os métodos da classe Convert para efetuar conversões.</p>
<h3>Parse/Format</h3>
<p>Estes são os métodos indicados quando existe intervenção do usuário, pois temos um bom controle de como será feita a conversão. Em ambos os métodos podemos especificar a formatação de duas formas:</p>
<ul>
<li>Indicando a “Culture”.</li>
<li>Fornecendo uma string de conversão, como por exemplo “dd/MM/yyyy”.</li>
</ul>
<p>Exemplo:</p>
<pre lang="csharp" line="1">string dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString, CultureInfo.InvariantCulture);</pre>
<p>Para o caso da língua portuguesa, o mais usual é usar o formato &#8220;pt-BR&#8221; para garantir a conversão correta e evitar erros de data inválida, por exemplo:</p>
<pre lang="csharp" line="1">DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(CultureInfo.CreateSpecificCulture("en-US")));
// Saída: 03/01/2008 07:00:00 
Console.WriteLine(date1.ToString(CultureInfo.CreateSpecificCulture("pt-BR")));
// Saída: 01/03/2008 07:00:00 </pre>
]]></content:encoded>
			</item>
		<item>
		<title>Struct DateTime</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/struct-datetime</link>
		<pubDate>Sun, 30 Aug 2009 00:49:16 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tratamento de Data e Hora]]></category>
		<category><![CDATA[Data]]></category>
		<category><![CDATA[DateTime]]></category>
		<category><![CDATA[Hora]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=270</guid>
		<description><![CDATA[O . NET Framework não tem um tipo intrínseco para data e hora. Existe, no entanto, a estrutura “DateTime” para armazenar e manipular este tipo de valores. O mesmo tipo armazena tanto data como hora. Isto é muito útil para manipular intervalos de tempo que passam de um dia. Note que a estrutura é um &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tratamento-de-data-e-hora/struct-datetime" class="more-link">Continue lendo <span class="screen-reader-text">Struct DateTime</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O . NET Framework não tem um tipo intrínseco para data e hora. Existe, no entanto, a estrutura “DateTime” para armazenar e manipular este tipo de valores. O mesmo tipo armazena tanto data como hora. Isto é muito útil para manipular intervalos de tempo que passam de um dia.</p>
<p>Note que a estrutura é um tipo por valor. As cópias e atribuições seguem as regras dos tipos por valor. O valor armazenado em um “DateTime” corresponde ao número de &#8220;ticks&#8221; transcorridos desde 01/01/0001, armazenados em um inteiro de 8 bytes. Cada tick corresponde a 100 nanosegundos. Veja um exemplo:</p>
<pre lang="csharp" line="1">DateTime D = new DateTime(tbAno.Text.ToInt32(), tbMes.Text.ToInt32() , tbDia.Text.ToInt32() );</pre>
<p>Existem diversos construtores para a criação de valores DateTime. O utilizado no exemplo acima cria um DateTime a partir de três inteiros representando ano, mês e dia. Existem também diversos métodos, como por exemplo:</p>
<ul>
<li>Now(): Extrai data e hora do sistema;</li>
<li>Today() : Extrai apenas data (hora é zerada);</li>
<li>Operadores para comparação, soma e subtração.</li>
</ul>
]]></content:encoded>
			</item>
	</channel>
</rss>
