Tag: csharp

Use an X.509 Certificate to encrypt the data protection keys in ASP.NET Blazor

In your Blazor application, modify the Program.cs file to configure data protection with certificate-based encryption.

using Microsoft.AspNetCore.DataProtection;
using System.Security.Cryptography.X509Certificates;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

// Configure Data Protection to use a certificate for key encryption
var certificate = X509CertificateLoader.LoadPkcs12FromFile("path_to_certificate.pfx", "password");
builder.Services.AddDataProtection()
    .ProtectKeysWithCertificate(certificate)
    .PersistKeysToFileSystem(new DirectoryInfo(keyFolderPath))
    .SetApplicationName("ERP");

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

app.Run();

 

Process all Objects in Entity Framework without loading all data into memory at once

1. Use AsAsyncEnumerable() for Streaming

EF Core 3.0+ supports AsAsyncEnumerable(), which streams results incrementally (similar to a cursor):

using Microsoft.EntityFrameworkCore;
using System.Linq;

var dbContext = new YourDbContext(); // Replace with your DbContext

var query = dbContext.YourEntities.AsNoTracking().AsAsyncEnumerable();

await foreach (var entity in query)
{
    // Process one entity at a time
    DateTime utcTime = entity.Time.ToUniversalTime();
    long epochSeconds = (long)(utcTime - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
    // ...
}

2. Use Raw SQL with Streaming

For complex queries, execute raw SQL and stream results:

var sql = "SELECT * FROM your_table";
var query = dbContext.YourEntities
    .FromSqlRaw(sql)
    .AsAsyncEnumerable();

await foreach (var entity in query)
{
    // Process entity
}

 

Process all documents in a MongoDB collection using C# without loading all data into memory at once

1. Use ToCursor and Process Documents Incrementally

The MongoDB C# driver supports iterating over results with a cursor, which retrieves documents in batches from the server (default batch size is 101 documents). This avoids loading all data into memory.

using MongoDB.Driver;
using MongoDB.Bson;

var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("YourDatabaseName");
var collection = database.GetCollection<BsonDocument>("YourCollectionName");

// Get a cursor to iterate over the collection
using (var cursor = await collection.Find(new BsonDocument()).ToCursorAsync())
{
    while (await cursor.MoveNextAsync())
    {
        foreach (var document in cursor.Current)
        {
            // Process one document at a time
            Console.WriteLine(document);
        }
    }
}

2. Process in Batches with BatchSize

Explicitly control the batch size to optimize memory usage:

var filter = Builders<BsonDocument>.Filter.Empty;
var options = new FindOptions<BsonDocument>
{
    BatchSize = 1000 // Adjust batch size based on your needs
};

using (var cursor = await collection.FindAsync(filter, options))
{
    while (await cursor.MoveNextAsync())
    {
        var batch = cursor.Current; // Process a batch of documents
        foreach (var document in batch)
        {
            Console.WriteLine(document);
        }
    }
}

3. Async Stream (C# 8+ with IAsyncEnumerable)

If using C# 8 or later, you can leverage IAsyncEnumerable for cleaner iteration:

await foreach (var document in collection.Find(new BsonDocument()).ToAsyncEnumerable())
{
    // Process one document at a time
    Console.WriteLine(document);
}

 

Transactions in Entity Framework

1. Using DbContextTransaction

Entity Framework allows you to manage transactions using the BeginTransaction method of the DbContext.

Example:

using (var context = new YourDbContext())
{
    using (var transaction = context.Database.BeginTransaction())
    {
        try
        {
            // Perform multiple operations
            var newEntity = new YourEntity { Name = "Example" };
            context.YourEntities.Add(newEntity);
            context.SaveChanges();

            var anotherEntity = new AnotherEntity { Value = "Test" };
            context.AnotherEntities.Add(anotherEntity);
            context.SaveChanges();

            // Commit transaction
            transaction.Commit();
        }
        catch (Exception ex)
        {
            // Rollback transaction if there is any error
            transaction.Rollback();
            Console.WriteLine(ex.Message);
        }
    }
}

2. Using TransactionScope

You can use the TransactionScope class for more advanced scenarios, which allows transactions across multiple DbContext instances.

Example:

using System.Transactions;

using (var scope = new TransactionScope())
{
    try
    {
        using (var context1 = new YourDbContext())
        {
            // Perform operations on first DbContext
            var entity1 = new YourEntity { Name = "Entity1" };
            context1.YourEntities.Add(entity1);
            context1.SaveChanges();
        }

        using (var context2 = new AnotherDbContext())
        {
            // Perform operations on second DbContext
            var entity2 = new AnotherEntity { Value = "Entity2" };
            context2.AnotherEntities.Add(entity2);
            context2.SaveChanges();
        }

        // Commit the transaction
        scope.Complete();
    }
    catch (Exception ex)
    {
        // Transaction will be rolled back automatically if not completed
        Console.WriteLine(ex.Message);
    }
}

3. Using EF Core with IDbContextTransaction

In Entity Framework Core, transactions are handled using the IDbContextTransaction interface.

Example:

using (var context = new YourDbContext())
{
    using (var transaction = await context.Database.BeginTransactionAsync())
    {
        try
        {
            // Perform database operations
            context.YourEntities.Add(new YourEntity { Name = "Entity1" });
            await context.SaveChangesAsync();

            context.AnotherEntities.Add(new AnotherEntity { Value = "Entity2" });
            await context.SaveChangesAsync();

            // Commit transaction
            await transaction.CommitAsync();
        }
        catch (Exception ex)
        {
            // Rollback transaction
            await transaction.RollbackAsync();
            Console.WriteLine(ex.Message);
        }
    }
}

 

Handle Clipboard Paste in WPF

public YourWindow()
{
    InitializeComponent();

    // "yourTextBox" is your TextBox
    DataObject.AddPastingHandler(yourTextBox, OnPaste);
}

private void OnPaste(object sender, DataObjectPastingEventArgs e)
{
    var isText = e.SourceDataObject.GetDataPresent(DataFormats.UnicodeText, true);
    if (!isText) return;

    var text = e.SourceDataObject.GetData(DataFormats.UnicodeText) as string;
    // Manipulate the text here
    text = text.Replace("oldValue", "newValue"); // Example manipulation

    // Set the new data
    e.DataObject = new DataObject(DataFormats.UnicodeText, text);
}

Note that this event is triggered after the user initiates the paste command but before the content is actually pasted into the TextBox, allowing you to modify or cancel the paste operation.

References
https://stackoverflow.com/questions/3061475/paste-event-in-a-wpf-textbox

Install chromedriver Automatically while using Selenium in C#

PM> Install-Package WebDriverManager
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using WebDriverManager;
using WebDriverManager.DriverConfigs.Impl;

namespace Test
{
    [TestFixture]
    public class Tests
    {
        private IWebDriver _webDriver;

        [SetUp]
        public void SetUp()
        {
            new DriverManager().SetUpDriver(new ChromeConfig());
            _webDriver = new ChromeDriver();
        }

        [TearDown]
        public void TearDown()
        {
            _webDriver.Quit();
        }

        [Test]
        public void Test()
        {
            _webDriver.Navigate().GoToUrl("https://www.google.com");
            Assert.True(_webDriver.Title.Contains("Google"));
        }
    }
}

References
https://github.com/rosolko/WebDriverManager.Net

Ignoring SSL certificate errors in C# RestSharp Library

//bypass ssl validation check by using RestClient object
var options = new RestClientOptions(baseurl) {
    RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
};
var restClient = new RestClient(options);

or in application level

//bypass ssl validation check globally for whole application.
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;

 

Ignoring SSL certificate errors in C# HttpClient

var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback = 
    (httpRequestMessage, cert, cetChain, policyErrors) =>
{
    return true;
};

var client = new HttpClient(handler);