C#

<pre>private void saveToPng_Click(object sender, RoutedEventArgs e)
        {

            string filePath = Environment.CurrentDirectory;
            var control = this.Control;

            RenderTargetBitmap rtb = new RenderTargetBitmap((int)control.ActualWidth, (int)control.ActualHeight, 96, 96, PixelFormats.Pbgra32);
            Rect bounds = VisualTreeHelper.GetDescendantBounds(control);
            DrawingVisual dv = new DrawingVisual();
            using (DrawingContext ctx = dv.RenderOpen())
            {
                VisualBrush vb = new VisualBrush(control);
                ctx.DrawRectangle(vb, null, new Rect(new Point(), bounds.Size));
            }
            rtb.Render(dv);

            PngBitmapEncoder png = new PngBitmapEncoder();
            png.Frames.Add(BitmapFrame.Create(rtb));

            using (Stream fileStream = new FileStream(filePath+"test.png", FileMode.Create))
            {
                png.Save(fileStream);
            }
        }

public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{

}

private void cmdLotto_Click(object sender, EventArgs e)
{
Form = new Form(LottoConverter);
Form.ShowDialog();
}

private void cmdEuro_Click(object sender, EventArgs e)
{
Form = new Form(EuroConverter); 
Form.ShowDialog();

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.Security.Cryptography.Pkcs;
using System.Security.Cryptography;
using System.Windows;
using System.Windows.Controls;
using System.Collections;
private static string senderCert = "sendername"; //the name registered in .p12 file
private static string receiverCert = "receivername"; //the name registered in .cer file
    /// <summary>
    ///verify that the receiving message is signed
    ///and returns the data without sign
    /// </summary>
    /// <param name="signedData">dataflow with sign</param>
    /// <returns></returns>
    public static byte[] Verify(this byte[] signedData)
    {
        X509Certificate2 certPub = GetReceiverCert(); 
        if (certPub == null) return null;

        ContentInfo decodeContentInfo = new ContentInfo(signedData);
        SignedCms decodeCMS = new SignedCms(decodeContentInfo, false);

        try
        {
            //decode the message, if it isn't signed, raise an exception
            decodeCMS.Decode(signedData);
            SignerInfo signerInfo = decodeCMS.SignerInfos[0];

            X509Certificate2Collection certCollection = new 
                        X509Certificate2Collection(certPub);                
            return decodeCMS.ContentInfo.Content;
        }
        catch (CryptographicException err)
        {
            Logger.Log(err);
            return null;
        }
    }

    /// <summary>
    /// Returns the certificate used to sign the sending messages
    /// </summary>
    /// <returns></returns>
    private static X509Certificate2 GetSenderCert()
    {
        //Open the personal certificates folder
        X509Store storeMy = new X509Store(StoreName.My, StoreLocation.CurrentUser);
        storeMy.Open(OpenFlags.ReadOnly);

        //find the proper certificate
        X509Certificate2Collection certColl = storeMy.Certificates.Find 
        (X509FindType.FindBySubjectName, senderCert, false);

        //Check if certificate exists in the collection, otherwise returns null             
            if (certColl.Count == 0)
            return null;
        storeMy.Close();
        return certColl[0];
    }

    /// <summary>
    /// Returns the certificate used to control the sign of the receiving messages
    /// </summary>
    /// <returns></returns>
    private static X509Certificate2 GetReceiverCert()
    {
        //Open personal certificates' folder
        X509Store storeMy = new X509Store(StoreName.My,
            StoreLocation.CurrentUser);
        storeMy.Open(OpenFlags.ReadOnly);

        //find the certificate use for this kind of messages
        X509Certificate2Collection certColl = storeMy.Certificates.Find 
                 (X509FindType.FindBySubjectName, receiverCert, false);

        //Check if certificate exists in the collection, otherwise returns null
        if (certColl.Count == 0)
            return null;
        storeMy.Close();
        return certColl[0];
    }

    /// <summary>
    /// Add a sign to the message
    /// </summary>
    /// <param name="data">message data flow</param>
    /// <returns></returns>
    public static byte[] Sign(this byte[] data)
    {
        X509Certificate2 certificate = GetSenderCert();
        if (certificate == null) return null;            
        if (data == null)
            throw new ArgumentNullException("data");
        if (certificate == null)
            throw new ArgumentNullException("certificate");

        //Set the message to sign
        ContentInfo content = new ContentInfo(data);
        signedCms = new SignedCms(content, false);
        CmsSigner signer = new CmsSigner(certificate);            
        signer.IncludeOption = X509IncludeOption.EndCertOnly; 

        //Create the sign
        signedCms.ComputeSignature(signer);
        return signedCms.Encode();
    }

public sealed class EventMessager : IEventMessager
{
    private readonly Dictionary<Type, object> subscriberLookup = new Dictionary<Type, object>();

    public IObservable<T> Observe<T>()
    {
        if (!subscriberLookup.TryGetValue(typeof(T), out object subject))
        {
            subject = new Subject<T>();
            subscriberLookup.Add(typeof(T), subject);
        }
        return ((ISubject<T>)subject).AsObservable();
    }

    public void Publish<T>(T @event)
    {
        if (subscriberLookup.TryGetValue(@event.GetType(), out object subject))
        {
            ((Subject<T>)subject).OnNext(@event);
        }
    }
}

eventMessager.Publish(Activator.CreateInstance(w[0]));