Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. Dopasowywanie wzorców w języku C#
POMOC .NET

C# Dopasowanie wzorca przełącznika (Jak to działa dla deweloperów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Praca z plikami PDF w C# często obejmuje obsługę różnych typów dokumentów, działań lub źródeł danych. Tradycyjnie, programiści mogą polegać na długich łańcuchach if-else lub zagnieżdżonych instrukcjach switch, aby zarządzać różnymi wartościami wejściowymi i typami lub decyzjami wyjściowymi. Ale dzięki nowoczesnym funkcjom C#, takim jak dopasowywanie wzorców w switch, twój kod może stać się znacznie bardziej elegancki, czytelny i łatwiejszy do utrzymania.

W połączeniu z potężną biblioteką PDF, taką jak IronPDF, dopasowywanie wzorców w switch pozwala budować mądrzejszą, czystszą logikę dla przetwarzania dokumentów. W tym artykule poznamy, jak używać zaawansowanych funkcji dopasowywania wzorców w C# — takich jak wzorce typów, wzorce właściwości i wzorce relacyjne — obok IronPDF, aby usprawnić przepływy pracy związane z generowaniem PDF.

What is Switch Pattern Matching in C#?

Dopasowywanie wzorców w switch to funkcja wprowadzona w C# 7 i nieustannie udoskonalana w późniejszych wersjach. W przeciwieństwie do tradycyjnych instrukcji switch, które dopasowują tylko stałe wartości, dopasowywanie wzorców pozwala oceniać typy, właściwości i warunki w ramach jednego wyrażenia. Poniższy przykład pokazuje, jak działa ta funkcja.

Składnia przykładowa

switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}
Select Case input
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case int i when i > 0:
	Case Integer i [when] i > 0
		Console.WriteLine("Positive integer")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case string s:
	Case String s
		Console.WriteLine($"It's a string: {s}")
	Case Else
		Console.WriteLine("Unknown type")
End Select
$vbLabelText   $csharpLabel

Ten kod używa wzorców typów, operatorów relacyjnych oraz wzorca stałej null, aby zwięźle obsługiwać wiele przypadków. Ta technika znacznie poprawia czytelność kodu dzięki bardziej zwięzłej składni i wspiera bardziej skomplikowaną logikę.

Dlaczego łączyć Dopasowywanie Wzorców w Switch z IronPDF?

Dopasowywanie Wzorców w Switch w C# (Jak to działa dla programistów): Rysunek 1 - Strona główna IronPDF

IronPDF to potężny komponent .NET do generowania i manipulowania plikami PDF z HTML, obrazów lub surowego tekstu. Wielu rzeczywistych przypadkach użycia obejmuje przetwarzanie różnych wzorców wejściowych: niektóre dokumenty mogą pochodzić z adresów URL, inne z ciągów HTML, a jeszcze inne z przesłanych plików.

Zamiast testować wyrażenia przy pomocy topornych warunków if, dopasowywanie wzorców w switch pozwala na efektywne wspieranie logiki opartej na wzorcach. Pozwala zdefiniować, jak aplikacja reaguje na różne typy obiektów, określone stałe, a nawet wyrażenia logiczne — używając samego wyrażenia wejściowego do sterowania przepływem pracy.

Typowe przypadki użycia w IronPDF z Dopasowywaniem Wzorców

W poprzednim przykładzie zobaczyliśmy, jak wygląda podstawowa składnia, ale teraz zobaczmy to w akcji. Poniższe przykłady kodu to niektóre rzeczywiste zadania związane z PDF, które korzystają z połączenia IronPDF z dopasowywaniem wzorców w C#.

1. Obsługa wielu formatów wejściowych za pomocą wzorców typów i właściwości

Powiedzmy, że twoja metoda akceptuje różne formaty wejściowe: HTML, Uri lub lokalny plik .html. Dzięki wzorcom typów, wzorcom właściwości i wzorcom null, możesz łatwo odróżnić te przypadki.

using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}
using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}
Imports System
Imports System.IO
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim input As Object = New Uri("https://example.com") ' Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
		Dim renderer = New ChromePdfRenderer()
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		PdfDocument pdfDoc = input switch
'		{
'			string html when html.StartsWith("<html>") => renderer.RenderHtmlAsPdf(html),
'			Uri url =>
'				renderer.RenderUrlAsPdf(url.ToString()),
'			FileInfo { Extension: ".html" } file =>
'				renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
'			null => throw new ArgumentNullException("Input was null."),
'			_ => throw new ArgumentException("Unsupported input type for PDF conversion.")
'		};
		pdfDoc.SaveAs("example-input-types.pdf")
		Console.WriteLine("PDF created: example-input-types.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Tutaj wzorzec właściwości (FileInfo { Extension: ".html" }) i wzorzec stałej null (przypadek null) czynią logikę bardziej wyrazistą i solidną.

2. Dynamiczne formatowanie PDF z wzorcami pozycyjnymi i deklaracyjnymi

Przypuśćmy, że używasz rekordu PdfRequest, który zawiera ciąg formatowania. Możesz zastosować wzorce pozycyjne, wzorce deklaracyjne i stałe ciągi, aby dostosować formatowanie PDF.

using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}
using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}
Imports System
Imports IronPdf
'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record PdfRequest(string Title, string Content, string Format)
Friend Class Program
	Shared Sub Main()
		Dim request As New PdfRequest("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4")
		Dim renderer = New ChromePdfRenderer()
		' Use fully qualified enum to avoid IronWord conflict
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		renderer.RenderingOptions = request switch
'		{
'			PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.A4
'			},
'			PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
'			},
'			_ => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
'			}
'		};
		Dim pdf = renderer.RenderHtmlAsPdf(request.Content)
		pdf.SaveAs("example-formatted.pdf")
		Console.WriteLine("PDF created: example-formatted.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

To użycie pokazuje, jak wyrażenie dopasowuje odpowiednią właściwość wewnątrz rekordu, podążając za logicznymi wzorcami opartymi na oczekiwanych wartościach.

Rozmiary wyjściowe

Dopasowywanie Wzorców w Switch w C# (Jak to działa dla programistów): Rysunek 2 - Różnica w rozmiarze wyjściu PDF

3. Role-oparte PDF przy użyciu wzorców var i not

Użyj wzorców var i not, aby obsługiwać role użytkowników, unikając stanów null lub nieoczekiwanych.

using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}
using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}
Imports System
Imports IronPdf
Public MustOverride ReadOnly Property UserRole() As record
public record Admin(String Email) : UserRole
public record Viewer(String Email) : UserRole
public record Guest() : UserRole
Dim Program As class
If True Then
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	static void Main()
'	{
'		UserRole currentUser = New Admin("admin@example.com"); ' Try changing to Viewer or Guest
''INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
''		var pdf = currentUser switch
''		{
''			Admin { Email: var email } => new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
''			Viewer =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
''			Guest =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
''			not null =>
''				throw new UnauthorizedAccessException("Unknown role type."),
''			null =>
''				throw new ArgumentNullException("Role cannot be null.")
''		};
'		pdf.SaveAs("example-role.pdf");
'		Console.WriteLine("PDF created: example-role.pdf");
'	}
End If
$vbLabelText   $csharpLabel

Ta struktura poprawia bezpieczeństwo i czytelność kodu, przy jednoczesnym wykorzystaniu deklaracji zmiennych tymczasowych, takich jak var email. Poniższy obraz pokazuje różne dokumenty PDF tworzone na podstawie różnych wartości wejściowych.

Dopasowywanie Wzorców w Switch w C# (Jak to działa dla programistów): Rysunek 3 - Wyjście oparte na roli

4. Dopasowywanie wzorców relacyjnych na podstawie danych użytkownika

Potrzebujesz generować różne PDF w zależności od poziomów użytkowników? Spróbuj użyć dwóch wzorców relacyjnych, aby sprawdzić, czy wejście mieści się w określonym zakresie.

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}
using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}
Imports System
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim userScore As Integer = 85 ' Try other values: 45, 70, 101
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		string message = userScore switch
'		{
'			< 60 => "Needs Improvement",
'			>= 60 and < 80 => "Satisfactory",
'			>= 80 and <= 100 => "Excellent",
'			_ => "Invalid score"
'		};
		Dim html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>"
		Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
		pdf.SaveAs("example-score.pdf")
		Console.WriteLine("PDF created: example-score.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Operatory relacyjne i wyrażenia logiczne utrzymują kod zwięzły i wyrazisty.

Wynik

Dopasowywanie Wzorców w Switch w C# (Jak to działa dla programistów): Rysunek 4 - Wyjście oparte na wyniku

Wskazówki dotyczące wdrożenia tego wzorca w projektach

Dopasowywanie Wzorców w Switch w C# (Jak to działa dla programistów): Rysunek 5 - Tabela skrótów dopasowywania wzorców C#

  • Używaj typów rekordów dla czystych i niemutowalnych obiektów danych.
  • Preferuj wyrażenia switch zamiast drzew if-else dla czystszej logiki.
  • Używaj wzorów not i wzorów ignorowania (_) do pomijania nieistotnych dopasowań.
  • Dodaj przypadki domyślne, aby wcześnie wychwycić nieznane wejścia.
  • Podziel złożone przypadki na metody pomocnicze dla czytelności.

Korzyści w praktyce

  • Czystszy kod: Koniec z głęboko zagnieżdżonymi blokami if-else czy switch-case
  • Łatwiejsze testowanie: Izolowane przypadki wzorców upraszczają testy jednostkowe
  • Elastyczność: Łatwe rozszerzenie logiki przy dodawaniu nowych typów wejściowych
  • Lepsze rozdzielenie odpowiedzialności: Skup logikę tylko na transformacji wejścia/wyjścia

Wniosek: Unowocześnij swoją logikę PDF

Dopasowywanie wzorców w switch to więcej niż tylko poprawa składniowa; to potężny paradygmat pisania bezpieczniejszego i bardziej wyrazistego kodu. W połączeniu z elastycznymi możliwościami renderowania IronPDF, można tworzyć mądrzejsze i bardziej skalowalne potoki generacji dokumentów z minimalnym kodem.

Niezależnie od tego, czy budujesz generator raportów, podglądarkę dokumentów, czy dynamiczny system szablonów, spróbuj dodać dopasowywanie wzorców do swojej implementacji IronPDF. Szybko zauważysz korzyści w przejrzystości, kontroli i łatwości utrzymania.

Chcesz wypróbować IronPDF samodzielnie?

Pobierz bezpłatną wersję próbną aby samodzielnie wypróbować potężne funkcje IronPDF przed zakupem licencji.

Często Zadawane Pytania

W jaki sposób dopasowywanie wzorców w języku C# może być zastosowane do przetwarzania dokumentów?

W języku C# można użyć dopasowania wzorców switch, aby uprościć złożoną logikę podejmowania decyzji. Po zintegrowaniu z biblioteką PDF, taką jak IronPDF, pozwala to programistom na bardziej efektywne zarządzanie zadaniami przetwarzania dokumentów poprzez usprawnienie logiki decyzyjnej i poprawę czytelności kodu.

Jakie są zalety stosowania dopasowywania wzorców switch w porównaniu z tradycyjnymi instrukcjami if-else?

Dopasowywanie wzorców switch zapewnia bardziej zwięzły i czytelny sposób obsługi wielu warunków w porównaniu z tradycyjnymi instrukcjami if-else. Zwiększa to łatwość utrzymania kodu C#, zwłaszcza podczas wykonywania złożonych zadań przetwarzania dokumentów przy użyciu IronPDF.

W jaki sposób dopasowywanie wzorców switch ułatwia automatyzację dokumentów PDF?

Dopasowywanie wzorców typu switch ułatwia automatyzację dokumentów PDF, umożliwiając programistom tworzenie przejrzystiejszej logiki do zarządzania różnymi działaniami związanymi z dokumentami i typami danych. W połączeniu z IronPDF pomaga zautomatyzować przepływy pracy i usprawnić procesy pozyskiwania danych.

Czy dopasowywanie wzorców może obsługiwać złożone przepływy pracy z dokumentami w języku C#?

Tak, dopasowywanie wzorców switch doskonale nadaje się do obsługi złożonych przepływów pracy z dokumentami w języku C#. Upraszcza ono logikę wymaganą do zarządzania różnymi typami dokumentów i działaniami, zwłaszcza gdy jest używane w połączeniu z solidnymi bibliotekami, takimi jak IronPDF.

Jak zaimplementować dopasowywanie wzorców switch w aplikacji do przetwarzania plików PDF napisanej w języku C#?

W aplikacji do przetwarzania plików PDF napisanej w języku C# można zaimplementować dopasowywanie wzorców za pomocą instrukcji switch z składnią dopasowywania wzorców w celu zarządzania różnymi typami dokumentów lub warunkami przetwarzania. Do obsługi rzeczywistych zadań związanych z manipulacją plikami PDF można użyć biblioteki IronPDF.

Jakie wyzwania mogą napotkać programiści podczas korzystania z dopasowywania wzorców switch w języku C#?

Programiści mogą napotkać trudności związane z dopasowywaniem wzorców switch podczas pracy z wzorcami dynamicznymi lub opartymi na środowisku uruchomieniowym, które wymagają bardziej złożonej logiki. Jednak przy prawidłowym użyciu w połączeniu z biblioteką taką jak IronPDF może to znacznie zwiększyć wydajność kodu.

W jaki sposób dopasowywanie wzorców switch wpływa na łatwość utrzymania kodu?

Dopasowywanie wzorców switch przyczynia się do łatwości utrzymania kodu, zapewniając jasny i zwięzły sposób obsługi wielu warunków. Zmniejsza to złożoność i sprawia, że kod jest łatwiejszy do zrozumienia i modyfikacji, zwłaszcza w aplikacjach na dużą skalę wykorzystujących IronPDF.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie