Flunt C# (Como funciona para desenvolvedores)

Como usar o Flunt em C

1. Crie um novo projeto de console em C#.
2. Instale o pacote Flunt a partir do NuGet.
3. Importe o namespace e faça com que a classe seja herdada.
4. Adicione a validação ao modelo de dados.
5. Realize as verificações de validação e exiba o resultado.

Entendendo o Flunt em C

O Flunt, um .NET Framework versátil e leve, foi criado para facilitar o desenvolvimento de padrões de validação e notificação fluentes em aplicações C#. O código torna-se mais legível e fácil de manter quando os desenvolvedores usam o Flunt para construir regras de validação e lógica de negócios de forma fluida e expressiva. Com a ampla gama de técnicas e extensões de validação integradas do Flunt, os desenvolvedores podem validar facilmente estruturas de dados complexas, como objetos e coleções.

Além disso, o Flunt é uma ferramenta útil para aumentar a confiabilidade e a robustez de aplicativos de biblioteca .NET , pois se integra facilmente com bases de código e frameworks existentes. Em suma, o Flunt incentiva uma abordagem declarativa para validação e tratamento de erros, permitindo que os desenvolvedores escrevam um código mais limpo e robusto.

Primeiros passos com o Flunt em C

Exemplo de Flunt C

Você pode usar o seguinte código Flunt assim que ele estiver instalado. Este é um exemplo simples que mostra como usar o Flunt para construir regras de validação:

using System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

        // Perform validation checks
        if (contract.IsValid)
        {
            Console.WriteLine("Person is valid!");
        }
        else
        {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}: {notification.Message}");
            }
        }
    }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class PersonContract : Contract<Person>
{
    public PersonContract(Person person)
    {
        // Ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

using System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

        // Perform validation checks
        if (contract.IsValid)
        {
            Console.WriteLine("Person is valid!");
        }
        else
        {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}: {notification.Message}");
            }
        }
    }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class PersonContract : Contract<Person>
{
    public PersonContract(Person person)
    {
        // Ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

Imports System
Imports Flunt.Validations

Public Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Name = "Jack",
			.Age = -25
		}
		Dim contract = New PersonContract(person)

		' Perform validation checks
		If contract.IsValid Then
			Console.WriteLine("Person is valid!")
		Else
			Console.WriteLine("Validation failed:")
			For Each notification In contract.Notifications
				Console.WriteLine($"- {notification.Key}: {notification.Message}")
			Next notification
		End If
	End Sub
End Class

Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Public Class PersonContract
	Inherits Contract(Of Person)

	Public Sub New(ByVal person As Person)
		' Ensure the correct format of the object
		Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
	End Sub
End Class

Person Classe: Representa uma entidade com propriedades Name e Age.

PersonContract: Esta classe deriva do conceito fundamental do Flunt de Contract<t>. Usando o método Requires, o construtor recebe um objeto Person e fornece regras de validação. Requires oferece um método encadeável para definir múltiplas validações. As validações são realizadas por métodos como IsNotNull, IsNotEmpty, IsGreaterThan. Cada regra de validação possui uma mensagem de erro personalizada associada.

Validação: Semelhante a um exemplo FluentValidation, isso cria uma instância de um objeto PersonContract e um objeto Person. Os resultados da validação são mostrados pelo atributo IsValid do contrato. As notificações de sucesso ou falha, bem como mensagens de erro específicas, são exibidas com base no resultado da validação.

Operações Fluentes

Para validação e tratamento de notificações em aplicações C#, o Flunt oferece diversas operações, tais como:

Criação de regras de validação: Para criar regras de validação para atributos como campos obrigatórios, tipos de dados, intervalos de valores, comprimento máximo e comprimento mínimo, utilize a interface fluente.

Executando a validação: Para garantir a integridade dos dados e a conformidade com a lógica de negócios, valide os objetos de acordo com regras predefinidas.

Gerenciando erros de validação: Anote e registre os erros de validação como alertas e responda a eles de forma educada, fornecendo mensagens de erro aos usuários ou registrando os erros para fins de solução de problemas.

Lógica de Validação Personalizada: Utilize regras de validação exclusivas para estender o Flunt em resposta a circunstâncias de validação complexas ou requisitos de domínio específicos.

Integração com frameworks: Para aprimorar os recursos de validação em aplicações atuais, o Flunt pode ser integrado facilmente a diversos frameworks e bibliotecas .NET conhecidos, incluindo Entity Framework, ASP.NET Core e muito mais.

Integrando o Flunt com o IronPDF

Os desenvolvedores podem aproveitar os pontos fortes de ambas as tecnologias para acelerar a validação da lógica de negócios e a criação de documentos em aplicativos C#, integrando o Flunt ao IronPDF. Os desenvolvedores podem tornar os aplicativos mais confiáveis ​​e fáceis de usar utilizando o IronPDF para criar documentos PDF após validar os dados de entrada com o Flunt.

Instale o IronPDF

• Inicie o projeto do Visual Studio.
• Selecione "Ferramentas" > "Gerenciador de Pacotes NuGet " > "Console do Gerenciador de Pacotes".
• Insira este comando no Console do Gerenciador de Pacotes:

Install-Package IronPdf

• Como alternativa, você pode usar o Gerenciador de Pacotes NuGet para Soluções para instalar o IronPDF e outros pacotes NuGet necessários.
• Clique no botão "Instalar" após explorar e selecionar o pacote IronPDF nos resultados da pesquisa. A instalação e o download serão gerenciados pelo Visual Studio.

• A instalação do pacote IronPDF e de quaisquer dependências necessárias para o seu projeto será feita pelo NuGet.
• Após a instalação, o IronPDF estará disponível para uso em seu projeto.

Implementando a lógica

Vamos criar uma aplicação básica em C# que utiliza o IronPDF para a criação de PDFs e o Flunt para a validação de dados. Neste exemplo, usaremos o Flunt para validar a entrada do usuário em um formulário de cadastro e o IronPDF para criar um documento PDF com um resumo dos dados do usuário que foram verificados.

1. Classe Pessoa: Uma classe Pessoa com atributos para nome e idade é definida. Validamos os dados da Pessoa em relação a regras de validação predefinidas usando a interface fluente do Flunt no construtor.
2. Gerar PDF: Um método chamado RenderHtmlAsPdf é definido e aceita um objeto User como entrada. Esta função renderiza o texto HTML que representa o resumo do registro do usuário em um documento PDF usando a classe HtmlToPdf do IronPDF.
3. Método Principal: Usando dados de exemplo da classe Pessoa, criamos uma instância da classe Usuário no método Principal. Em seguida, usamos o atributo IsValid do Flunt para determinar se os dados da Pessoa são legítimos. Para criar o documento PDF, invocamos o método IronPDF se os dados estiverem corretos. Caso contrário, os problemas de validação serão exibidos no console.

Desenvolvemos um fluxo de trabalho rápido para avaliar a entrada do usuário e gerar documentos PDF em um aplicativo C#, combinando o IronPDF para geração de PDF com o Flunt para validação de dados. Este método garante a integridade dos dados, gera documentos de qualidade profissional e incentiva a escrita de código claro, legível e de fácil manutenção. Para saber mais sobre as funcionalidades do IronPDF, consulte a página de documentação . Abaixo segue um exemplo de trecho de código.

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder for HTML content
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);

            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer object
            renderer.Dispose();
            // Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
                .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder for HTML content
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);

            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer object
            renderer.Dispose();
            // Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
                .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

Imports IronPdf
Imports System
Imports System.Linq
Imports System.Text
Imports Flunt.Validations

Namespace ConsoleApp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' StringBuilder for HTML content
			Dim sb As New StringBuilder()
			Dim person As New Person With {
				.Name = "Jack",
				.Age = -25
			}
			Dim contract = New PersonContract(person)

			If contract.IsValid Then
				Console.WriteLine("Person is valid!")
				sb.Append("<p>Person is valid!</p>")
			Else
				sb.Append("<p>Validation failed: </p>")
				For Each notification In contract.Notifications
					sb.Append($"- {notification.Key}: {notification.Message}<br>")
				Next notification
			End If

			Dim renderer = New HtmlToPdf()
			' Set HTML content for the page
			Dim pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString())
			' Save the document
			pdfDocument.SaveAs("output.pdf")
			' Dispose the renderer object
			renderer.Dispose()
			' Display a message
			Console.WriteLine("Report generated successfully!")
		End Sub
	End Class

	Public Class Person
		Public Property Name() As String
		Public Property Age() As Integer
	End Class

	Public Class PersonContract
		Inherits Contract(Of Person)

		Public Sub New(ByVal person As Person)
			Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
		End Sub
	End Class
End Namespace

Abaixo está o resultado da execução do código acima:

Conclusão

IronPDF e Flunt são duas bibliotecas C# robustas que funcionam bem juntas para otimizar os fluxos de trabalho de criação de documentos e validação de dados. Com os recursos sofisticados de produção de PDF do IronPDF e as robustas capacidades de validação do Flunt, os desenvolvedores podem criar soluções confiáveis, eficazes e de alta qualidade para uma variedade de aplicações. Flunt e IronPDF fornecem aos desenvolvedores as ferramentas necessárias para criar softwares de alta qualidade que atendam às necessidades dos usuários e das partes interessadas, seja no desenvolvimento de aplicativos para desktop, aplicativos web ou soluções baseadas em nuvem.

Um ano de suporte de software, uma licença permanente e uma atualização da biblioteca estão incluídos no pacote $799 Lite. A IronPDF fornece detalhes gratuitos sobre a licença do IronPDF. Para mais informações sobre custos e requisitos de licenciamento, entre em contato conosco. Para obter informações adicionais sobre as bibliotecas da Iron Software , visite o site oficial da Iron Software .