XML Correto

<elemento atributo='Stacem'>Formula matemática do item</elemento>

XML corrompido

<elemento atributo='St'acem'>Valor de X > que valor de Y.</elemento>

Para resolver esse problema, devesse utilizar em campos de informações (valores dos elementos ou atributos) um “encode” para esses caracteres.

Encode XML

Basicamente são 5 valores:

No Framework.NET existem alguns caminhos de aplicar o encode XML:

1. string.Replace()
A maneira mais feia, mas que funciona, seria utilizar o famoso string.Replace().
Repetindo a rotina 5 vezes, uma para cada caracter especial.

string text = "Este é um \"nó\" XML com caracteres 'especiais' & <> diferente de tudo!!";
string encodedXml = text.Replace("&", "&amp;").Replace("< ", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;").Replace("'", "&apos;");
// RESULT: Este é um &quot;nó&quot; XML com caracteres &apos;especiais&apos; &amp; &lt;&gt; diferente de tudo!!

2. System.Web.HttpUtility.HtmlEncode()
É utilizado para codificar textos em HTML, muito utilizado em ASP.NET, porem ele não codifica o apóstrofo e força você utilizar uma referência de pacote Web. Se for uma aplicação desktop, não recomendo sua utilização.

string text = "Este é um \"nó\" XML com caracteres 'especiais' & <> diferente de tudo!!";
string encodedXml = HttpUtility.HtmlEncode(text);
// RESULT: Este é um &quot;nó&quot; XML com caracteres 'especiais' &amp; &lt;&gt; diferente de tudo!!

3. System.Security.SecurityElement.Escape()
Outra maneiroa é utilizar o comando Escape() que trata os 5 caracteres especiais.

string text = "Este é um \"nó\" XML com caracteres 'especiais' & <> diferente de tudo!!";
string encodedXml = System.Security.SecurityElement.Escape(text);
// RESULT: Este é um &quot;nó&quot; XML com caracteres &apos;especiais&apos; &amp; &lt;&gt; diferente de tudo!!

Gosto muito da opção de codificar com System.Security.SecurityElement.Escape(), acredito que seja a forma mais estética com relação ao código.
Não sei quanto a desempenho das formas, mas manipulação de string não é a melhor das escolhas.
E a segunda alem de não abranger todos os caracteres especiais, ainda fica limitada a aplicações web.

Espero ter ajudado

O Framework .NET possui o objeto Thread que permite mais flexibilidade e gerenciamento sobre as thread executadas em background do que o objeto ThreadPool.

Thread Priority
Uma das propriedades do objeto Thread á sua prioridade. Após a thread criada, mas antes de iniciar a thread, podemos definir a prioridade da thread com propriedade Thread.Priority usando o enumerador ThreadPriority.
A Thread priority controla como o sistema operacional irá agendar o tempo para a execução da Thread. Geralmente threads com maior prioridade rodam antes das threads com baixo prioridades, por padrão as threads tem o valor de prioridade definida como Normal.

Thread State
Outra propriedade do objeto é Thread.ThreadState pode ser utilizada para verificar o estado das threads em background.
Os estados possíveis são:

• Unstarted: estado inicial da thread (antes de executar o método Thread.Start).
• Running: estado ativo ou executando (após de executar o método Thread.Start).
• Stopped: estado parada.
• WaitSleepJoin: estado esperando outra thread completar.
• SuspendRequested: estado repondendo solicitanção de pausa.
• Suspended: estado suspensa.
• AbortRequested: estado respondendo a solicitanção de abandono.
• Aborted: estado abortado.

Thread com parâmetros e retorno em C#

Para fornecer parâmetros para uma thread, criamos uma classe com um construtor que recebe um ou mais parâmetros e armazena o dado e a usa para criar o objeto ThreadStart.
Para obter o retorno da Thread, criamos um método que recebe o resultado de retorno como uma parâmetro. Depois criamos um delegate para o método e passamos o delegado e próprio método como parâmetro para a classe.

using System;
using System.Threading;
 
namespace ManagerThread
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Calculator calculator = new Calculator("Multiplicador", 15, ResultCallback);
 
            Thread thread = new Thread(calculator.Execute);
            thread.Start();
 
            Console.WriteLine("Main Thread aguarda finalização das threads em background.");
            thread.Join();
            Console.WriteLine("Thread completada.");
            Console.ReadKey();
        }
 
        public static void ResultCallback(int value)
        {
            Console.WriteLine("Resultado: {0}", value);
        }
    }
 
    public class Calculator
    {
        // Delegate que define a assinatura do método de callback (retorno).
        public delegate void ResultDelegate(int value);
 
        private readonly ResultDelegate callback;
        private readonly string message;
        private readonly int value;
 
        public Calculator(string message, int value, ResultDelegate callback)
        {
            this.message = message;
            this.value = value;
            this.callback = callback;
        }
 
        public void Execute()
        {
            Console.WriteLine(message);
 
            if (callback != null)
            {
                callback(value*2);
            }
        }
    }
}

A thread é executada somente após o comando thread.Start(). O comando thread.Join() força a thread principal a ficar aguardando a finalização da thread em background para seguir o processo.

Observações:
Threads podem estar em mais de 1 estado ao mesmo tempo.
Os métodos Thread.Suspend e Thread.Resume são utilizados para pausar e retornar a thread principal. Porem estes métos esta depreciados, e podem causar problemas de execuação, utilize o método Thread.Abort().

Enjoy

1. Determinar quais objetos não mais será utilizado, ou seja, não estão mais acessíveis na aplicação;
2. Liberar os recursos (memória) utilizados por esses objetos

Entendendo o funcionamento do Garbage Collector

Basicamente o GC divide a memória disponível em 3 áreas distintas:

1. Maneged Heap
2. Pilha
3. Unmanaged Heap

O GC em conjunto com a CLR por meio de diversos algoritmos executa o gerenciamento da área de memória managed heap, que aloca reference types. Enquanto a pilha é utilizada para alocar value types. A unmanaged heap é utilizada para armazenar recursos não gerenciados de forma automática ou recursos nativos.
Mais detalhe da arquitetura do GC ficará para um próximo post, pois irá envolver alguns temas ainda não tratados.

Recursos Não Gerenciados

Um ponto importante é controle de recursos não gerenciados (recursos nativos, que pode ser um arquivo, janela, conexões de banco de dados, sockets, Win32, entre outros).
Implicitamente o Framework.NET mantém um controle das instâncias utilizadas pela aplicação, porem o mesmo não se repete para recursos não gerenciados. Para recursos não gerenciados deve-se fornecer uma maneira de liberar os recursos da memória depois que o aplicativo tiver terminado de usá-los, ou seja, deve ser um processo manual (codificado) executado pelo programador.
Há duas maneiras de se finalizar um recurso não gerenciado:

• Implicitamente utilizando o método Finalize();
• Explicitamente utilizando o método Dispose() do IDisposable;

Observação: Por padrão a Microsoft recomenda a implementar as duas formas de finalizar o objeto. Sendo que o método Finalize() serve de garantia de execução de liberação de memória impedindo que o recurso fique permanentemente vazando caso algum programador esqueça de chamar o método Dispose().

A primeira impressão que temos ao ver o finalizador (redefinindo ao método Finalize de System.Object) existente no .NET é que este atua como um destruidor (destructor) presente em linguagens com C/C++ é que são similares. Porem não se iluda pela aparência, pois são bem diferentes em suas características.

Caracteristicas do Finalizador:

• Execução nem sempre é não garantida;
• Execução não determinística (instante em que o método é executado não é conhecido);
• Chamada ao método ocorre desde que não existam ciclos infinitos;
• Quando chamado shutdown, sua execução só ocorre caso seu tempo de execução não seja superior a 2 segundos e o somatório não exceda 40 segundos (tempos aproximados);

Em resumo o CLR não garante a ordem de chamada dos métodos Finalize().

Exemplo de implementação do finalize:

Código C#.NET:

1
2
3
4
5
6
7
8
9

public class AlgumaClasse
{
   …
   ~AlgumaClasse() // finalizador
   {
      // código de limpeza
   }
   …
}

Codigo gerado pelo compilador:

1
2
3
4
5
6
7
8
9
10

public class AlgumaClasse
{
   …
   protected override void Finalize()
   {
      try { /* código de limpeza */ }
      finally { base.Finalize(); }
   }
   …
}

O método Dispose é uma implementação de um padrão conhecido como “padrão de descarte” e impõe uma ordem na vida de um objeto.
O método Dispose() deve liberar os recursos que ele possui assim como os recursos de propriedade de seus tipos base. Esse processo é executado através de uma hierarquia de tipos de base, ou seja, cada objeto irá chamar o método Dispose() da classe estendida ou implementada. Garantindo assim que os recursos são sempre limpos adequadamente.
Um característica particular do método Dispose() é que este pode ser chamado várias vezes sem lançar exceção.
É importante salientar que não há benefícios de desempenho na utilização do método Dispose() a objetos gerenciados pela CLR (tais como Arrays). Este método deve ser utilizado em objetos que utilizam recursos nativos e objetos COM que são expostas ao Framework.NET, como exemplo podemos citar a classe FileStream que implementa a interface IDisposable.

Exemplo de implementação do métiodo Dispose():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// Design pattern para uma classe base.
public class Base: IDisposable
{
   //Implementação da interface IDisposable.
   public void Dispose() 
   {
     Dispose(true);
      GC.SuppressFinalize(this); 
   }
 
   protected virtual void Dispose(bool disposing) 
   {
      if (disposing) 
      {
         // libera outros estados (managed objects).
      }
      // Libera sus próprios estados(unmanaged objects).
      // Define campos grandes como null.
   }
 
   // Sintaxe para finalização do código.
   ~Base()
   {
      //Chamada simples Dispose(false).
      Dispose (false);
   }
}
// Design pattern para a classe derived.
public class Derived: Base
{   
   protected override void Dispose(bool disposing) 
   {
      if (disposing) 
      {
         // Liberação de recursos gerenciados
      }
      // Liberação de recusos não gerenciados.
      // Define campos grandes como null.
      // Chama Dispose da classe base.
      base.Dispose(disposing);
   }
   // A classe derived não tem o método Finalize
   // ou um método Dispose com parametro pois herda da classe base.
}

Enjoy

Primeiramente vamos conceiturar o que é socket, ou soquete em portugues. De uma visão geral um soquete pode ser definido como uma tomada que designa uma cavidade ou região usada para ligar algum artifício específico.

No mundo da computação, um socket é o elo de ligação entre os processos do servidor e do cliente. Ele é a “porta” na qual os processos enviam e recebem mensagens. De acordo com JAMES F KUROSE: “socket é a interface entre a camada de aplicação e a de transporte dentro de uma máquina”. Para quem não lembra, ou não sabe, camada de aplicação e transporte fazem parte do modelo OSI.
Através de um socket podemos estabelecer a comunicação entre máquinas possibilitando o envio e recebimento de dados.

A interface padronizada de sockets surgiu originalmente no sistema operacional Unix BSD (Berkeley Software Distribution). Tinha a função de suporte a comunicação em rede. Esta interface é a base para a maioria das interfaces entre protocolos de internet TCP/IP existente.

A identificação de um socket na rede é realizada por um IP e um porta. Comumente utiliza-se portas acima de 1000 pois as inferiores são utilizadas pelo sistema operacional. Sua comunicação é realizada pelos protocolos UDP ou TCP. Assim, é possível termos tanto comunicação orientada a conexão (via TCP), quanta não orientada a conexão (via UDP). O socket abstrai esse conceito, permitindo assim a utilização de qualquer um dos meios.

No C# para se trabalhar com sockets os recursos enconstram-se no namespace System.Net.Sockets.

Implementando uma aplicação com socket

Este é um simples código de uma aplicação Client/Server utilizando socket.
Abaixo o passo a passo de criação da aplicação:

Server App

1. Criar um projeto do tipo WindowsForm com o nome CommunicationSocket.
2. Incluir um botão que será utilizado para enviar mensagem do servidor para o cliente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Windows.Forms;
 
namespace CommunicationSocket
{
    public partial class ServerApp : Form
    {
        private Socket socket;
        private Thread thread;
 
        private NetworkStream networkStream;
        private BinaryWriter binaryWriter;
        private BinaryReader binaryReader;
 
        public ServerApp()
        {
            InitializeComponent();
            thread = new Thread(new ThreadStart(RunServer));
            thread.Start();
        }
 
        public void RunServer()
        {
            TcpListener tcpListener;
            try
            {
                IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2001);
                tcpListener = new TcpListener(ipEndPoint);
                tcpListener.Start();
 
                MessageBox.Show("Servidor habilitado e escutando porta...", "Server App");
 
                socket = tcpListener.AcceptSocket();
                networkStream = new NetworkStream(socket);
                binaryWriter = new BinaryWriter(networkStream);
                binaryReader = new BinaryReader(networkStream);
 
                MessageBox.Show("conexão recebida!", "Server App");
                binaryWriter.Write("\nconexão efetuada!");
 
                string messageReceived = "";
                do 
                {
                    messageReceived = binaryReader.ReadString();
                    MessageBox.Show("Mensagem: " + messageReceived, "Server App");
 
                } while (socket.Connected);
            } 
            catch (Exception ex) 
            {
                MessageBox.Show(ex.Message);
            } 
            finally 
            {
                binaryReader.Close();
                binaryWriter.Close();
                networkStream.Close();
                socket.Close();
 
                MessageBox.Show("conexão finalizada", "Server App");
            }
        }
 
        private void btnSendMsg_Click(object sender, EventArgs e)
        {
            try
            {
                binaryWriter.Write("Server respondendo: Houston, we have a problem!!!");
            }
            catch (SocketException socketEx)
            {
                MessageBox.Show(socketEx.Message, "Erro");
            }
        }
    }
}

Client App

1. Criar um projeto do tipo WindowsForm com o nome ClientApp.
2. Incluir botão que será utilizado para enviar mensagem do cliente para o servidor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Windows.Forms;
 
namespace ClientApplication 
{
    public partial class ClientAppForm : Form 
    {
        private NetworkStream networkStream;
        private BinaryWriter binaryWriter;
        private BinaryReader binaryReader;
        private TcpClient tcpClient;
 
        private Thread thread;
 
        public ClientAppForm() 
        {
            InitializeComponent();
            thread = new Thread(new ThreadStart(RunClient));
            thread.Start();
        }
 
        public void RunClient() 
        {
            try 
            {
                tcpClient = new TcpClient();
                tcpClient.Connect("127.0.0.1", 2001);
 
                networkStream = tcpClient.GetStream();
                binaryWriter = new BinaryWriter(networkStream);
                binaryReader = new BinaryReader(networkStream);
 
                String message = "";
                do 
                {
                    try 
                    {
                        message = binaryReader.ReadString();
                        MessageBox.Show(message, "Mensagem Recebida");
                    } 
                    catch (Exception ex) 
                    {
                        MessageBox.Show(ex.Message, "Erro");
                        message = "FIM";
                    }
                } while (message != "FIM");
 
                binaryWriter.Close();
                binaryReader.Close();
                networkStream.Close();
                tcpClient.Close();
            } 
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Erro");
            }
        }
 
        private void btnSendMsg_Click(object sender, EventArgs e) 
        {
            try 
            {
                binaryWriter.Write("Mensagem do cliente");
            } 
            catch (SocketException socketEx) 
            {
                MessageBox.Show(socketEx.Message, "Erro");
            }
        }
    }
}

Para realizar a comunicação o Servidor utiliza o objeto TcpListener que fica escutando toda requisição no IP “127.0.0.1″ porta 2001.
Na aplicação Cliente o objeto TcpClient é informado sobre o IP (ou DNS) e porta do servidor que irá se conectar. Após esse a realização toda a comunicação é feita por meio de stream através do objeto NetworkStream.

Repare que tanto Servidor quanto o Cliente trabalha com processamento em paralelo (Thread) para evitar que a aplicação fique travada até o término do processamento, ou para manter um processamento dedicado e contínuo que é o caso do servidor.

Nesse exemplo utilizei MessageBox para apresentar as mensagens, pois para inseri-las em um TextBox no Form é necessário utilizar delegates e reflections, senão teremos um erro de cruzamento de Threads (Cross-thread operation not valid).
Mas isso acho que é assunto para o nosso próximo post.

Até mais

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System.Text.RegularExpressions; 
namespace ExtensionMethodsExample
{
    public class Util
    {
        /// <summary>Verifica se o argumento do tipo string é um numérico</summary>
        /// <param name="arg">argumento a ser validado</param>
        /// <returns>True - se for numérico</returns>
        public bool IsNumeric(string arg)
        {
            return Regex.IsMatch(arg, @"^\d+$");
        }
    }
}

Com o uso do Extension Methods podemos inserir o método que verifica se a variável é numérica no próprio tipo string.
Abaixo um exemplo de seu uso, e depois vou explicar como o extension methods é declarado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using System;
using System.Text.RegularExpressions;
 
namespace ExtensionMethodsExample
{
    public static class Extensions
    {
        public static bool IsNumeric(this string arg)
        {
             return Regex.IsMatch(arg, @"^\d+$");
        }
    }
} 
 
public class Program
{
    public static void Main(string[] args)
    {
        string codigo1 = "1234";
        string codigo2 = "ABCD";
 
        Imprime(codigo1);
        Imprime(codigo2);
    }
 
    private static void Imprime(string codigo)
    {
        if (codigo.IsNumeric())
        {
            Console.WriteLine("Codigo numerico: {0}", codigo);
        }
        else
        {
            Console.WriteLine("Codigo alphanumerico: {0}", codigo);
        }
    }
}

Para criarmos um extension methods precisamos de uma classe e método estático. Todo método extension sempre terá seu primeiro parâmetro a palavra reservada this, seguido do tipo ao qual o método será inserido, no exemplo o tipo string. Esse parâmetro representa a própria instância do objeto. Para os parâmetros subseqüentes serão utilizados na chamada do método. O nome da classe é de livre escolha, ela não interfere na implementação do extension methods, a única ressalva é que seja uma classe estática.

Compare a diferença da verificação de condição utilizando a classe Util e o extension methods

1
2
3
4
5

Util util = new Util();
if (util.IsNumeric(codigo))
{
    // faz algo
}

e

1
2
3
4

if (codigo.IsNumeric())
{
    // faz algo
}

O código torna-se mais legível e mais implícito seus métodos, tornando a linguagem muito mais dinâmica.
Enjoy

Basicamente reflection é uma maneira de se descobrir dados de uma classe/objeto/interface em tempo de execução. Dessa forma podemos examinar os tipos em um assembly e interagir com eles ou instanciá-los. Também podemos criar tipos no momento de execução.

Neste post criarei um exemplo de instânciar objetos em tempo de execução (runtime) utilizando reflection.
Abaixo segue um diagrama de classe do modelo utilizado para o exemplo:

Utilizando reflection

using System;
using System.Collections.Generic;
using System.Reflection;
 
namespace UtilizandoReflection {
    public class Program {
        public static void Main(string[] args) {
 
            StateFactory factory = new StateFactory();
 
            // Cria 3 produtos em estado diferentes
            Product product1 = new Product();
            Product product2 = new Product();
            Product product3 = new Product();
 
            product1.State = factory.Create(1, "item pendente");
            product2.State = factory.Create(2, "item no estoque");
            product3.State = factory.Create(3, "item vendido");
 
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product1.State.ID, product1.State.Description, product1.State.GetType().ToString());
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product2.State.ID, product2.State.Description, product2.State.GetType().ToString());
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product3.State.ID, product3.State.Description, product3.State.GetType().ToString());
        }
    }
 
    /// <summary>Classe responsável por criar intâncias de estado</summary>
    public class StateFactory {
        private Dictionary<int, string> states;
 
        public StateFactory(){
            states = new Dictionary<int, string>(3);
            states.Add(1, "Pending");
            states.Add(2, "Stock");
            states.Add(3, "Sold");
        }
 
        /// <summary>Cria uma instância de estado</summary>
        /// <param name="ID">Identificador da instância</param>
        /// <param name="description">descrição do estado</param>
        /// <returns>Estado</returns>
        public State Create(int ID, string description) {
 
            string baseName = "UtilizandoReflection";
 
            // cria array com os parâmetro utilizado no construtor do estado
            object[] args = new object[2];
            args.SetValue(ID, 0);
            args.SetValue(description, 1);
 
            //using System.Reflection
            Assembly assembly = Assembly.Load(baseName);
            return (State)assembly.CreateInstance(baseName + "." + states[ID], true, BindingFlags.CreateInstance, null, args, null, null);
        }
    }
 
    #region Domain
    public class Product {
        public State State;
    }
    public abstract class State {
        public int ID;
        public string Description;
        public State(int ID, string description) {
            this.ID = ID;
            this.Description = description;
        }
    }
    public class Pending : State { // estado pendente
        public Pending(int ID, string description) : base(ID, description) { }
    }
    public class Stock : State { // estado estoque
        public Stock(int ID, string description) : base(ID, description) { }
    }
    public class Sold : State { // estado vendido
        public Sold(int ID, string description) : base(ID, description) { }
    }
    #endregion
}

Resultado da execução:

Produto 1: item pendente -- Type UtilizandoReflection.Pending
Produto 2: item no estoque -- Type UtilizandoReflection.Stock
Produto 3: item vendido -- Type UtilizandoReflection.Sold


Observe que as classes a serem instanciadas por reflection estão na mesma solution ou project, assim utilizamos o método Load do Assembly, porem quando a classe a ser utilizada for de uma DLL, utilizamos o método LoadFile e informamos o nome completo da DLL.

Como mencionado no início do post, há outras utilizações de reflection, como manipular atributos e métodos, mas isso é assunto para um próximo post.

Enjoy

Alguns caracteres na expressão regular que têm funções especiais, e recebem o nome de metacaracteres, a combinação desses símbolos com caracteres literais da-se a criação de expressão.

Com a expressão regular é possível validar padrões de escrita como:

• Número IP
• E-mail
• CPF

Para aprender a sintaxe utilizada na criação da expressão regular, segue uma versão on-line da obra de Expressões Regulares – Guia de Consulta Rápida.

OBSERVAÇÕES:

Em Java suporte a expressões regulares tem sido parte da plataforma Java desde a versão 1.4. e está contidas no pacote java.util.regex .

EM C# para utilizar expressões regulares, precisamos incluir o namespace System.Text.RegularExpressions .

Exemplo de expressão regulares com C#

Para testar a utilização de expressão regular, criei um projeto do tipo Console Application, e inclui o seguinte código.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

public static void Main(string[] args)
        {
            // expressões para filtrar as palavras a serem apresentadas
            // cria padrão para todas as palavras que contenham a expressão ATO
            string padrao1 = ".ato";
            // cria padrão para todas as palavras que contenham caracteres especias
            string padrao2 = ".\\?|.\\+|.\\!";
            // cria padrão para todas as palavras que contenham caracteres numéricos
            string padrao3 = "[0-9]";
 
            // cara lista para armazenar as palavras a serem filtradas
            List<string> paravras = new List<string>(10);
 
            paravras.Add("9pato");
            paravras.Add("rat3o");
            paravras.Add("mato");
            paravras.Add("gato");
            paravras.Add("te5to");
            paravras.Add("ramo");
            paravras.Add("duv6ida?");
            paravras.Add("soma+");
            paravras.Add("opa?");
            paravras.Add("que!");
 
            // Cria objetos que representa uma expressão regular
            Regex regex1 = new Regex(padrao1);
 
            Console.WriteLine("Busca de palavras com o padrão ATO");
            Console.WriteLine("");
 
            foreach (string str in paravras)
            {
                // verifica se palavra esta de acordo com o padrão
                // se for verdadeiro entra dentro do laço
                if (regex1.IsMatch(str))
                {
                    Console.WriteLine(str);
                }
            }
 
            // Cria objetos que representa uma expressão regular
            Regex regex2 = new Regex(padrao2);
 
            Console.WriteLine("");
            Console.WriteLine("Busca de palavras com caracteres especias");
            Console.WriteLine("");
 
            foreach (string str in paravras)
            {
                if (regex2.IsMatch(str))
                {
                    Console.WriteLine(str);
                }
            }
 
            // Cria objetos que representa uma expressão regular
            Regex regex3 = new Regex(padrao3);
 
            Console.WriteLine("");
            Console.WriteLine("Busca de palavras que contenham o caracteres numericos");
            Console.WriteLine("");
 
            foreach (string str in paravras)
            {
                if (regex3.IsMatch(str))
                {
                    Console.WriteLine(str);
                }
            }
        }

Até mais…