lam0x86

У тех колонок/строк, в которых находятся элементы с фиксированным размером, нужно проставить Auto в свойствах Width/Height.

<RowDefinition Height="Auto"></RowDefinition>
<ColumnDefinition Width="Auto"></RowDefinition>

<Label
  Content="{Binding ElementName=slider1, Path=Value}"
  ContentStringFormat="{}Выбрано {0} единиц"
  DockPanel.Dock="Top"
/>

Это обычные сериализованные значения double.

Читать его можно так:

using (var reader = new BinaryReader(File.Open("<file path>", FileMode.Open)))
{
  var value1 = reader.ReadDouble();
  var value2 = reader.ReadDouble();
 ...
}

А записывать - так:

using (var bw = new BinaryWriter(File.Create("<file path>")))
{
  double value1 = 2;
  double value2 = 17950.015625;
  bw.Write(value1);
  bw.Write(value2);
}

Надо поставить свойство StrokeLineJoin в Bevel.

Как я понял задачу: у вас есть две сущности, реализация которых неизвестна:

• подписываемый объект
  
• сервис генерации подписи
  

Объект ничего не знает, каким сервисом он будет подписан, а сервис не знает, какая структура у подписываемого объекта.
В этом случае логично ввести некую промежуточную сущность, в которую объект может себя сериализовать, а сервис будет знать, как её подписать. В простейшем случае это может быть массив, например, byte[]. Можно придумать более изощренный способ с потоковой генерацией подписи, чтобы не создавать промежуточный объект.

Может, я неправильно понял задачу, но вот, что у меня вышло.

Интерфейсы:

public interface ISignable
{
    ISignature Signature { get; set; }
    byte[] Serialize();
}

public interface ISignature
{
}

public interface ISignatureService
{
    bool Validate(ISignable signable);
    void Sign(ISignable signable);
}

Простейшая имплементация (в качестве подписи используется просто хеш-код):

class MyObject : ISignable
{
    public ISignature Signature { get; set; }
    public long Param1 { get; set; }
    public string Param2 { get; set; }
    public string InnerData { get; set; }

    public byte[] Serialize()
    {
        return Encoding.UTF8.GetBytes(Param1 + Param2 + InnerData);
    }
}

public class HashCodeSignatureService : ISignatureService
{
    public void Sign(ISignable signable)
    {
        var signature = CalculateSignature(signable);
        signable.Signature = signature;
    }

    public bool Validate(ISignable signable)
    {
        var s1 = CalculateSignature(signable);
        var s2 = signable.Signature as SimpleHashCodeSignature;
        return s1?.HashCode == s2?.HashCode;
    }

    private static SimpleHashCodeSignature CalculateSignature(ISignable signable)
    {
        var body = signable.Serialize();
        var signature = new SimpleHashCodeSignature(body.Aggregate(0, (a, b) => a + b.GetHashCode()));
        return signature;
    }
}

public class SimpleHashCodeSignature : ISignature
{
    public int HashCode { get; }

    public SimpleHashCodeSignature(int hashCode)
    {
        HashCode = hashCode;
    }
}

А так это можно использовать:

class Program
{
    static void Main(string[] args)
    {
        var obj = new MyObject {Param1 = 1, Param2 = "asd", InnerData = "some data"};
        var signatureService = new HashCodeSignatureService();
        signatureService.Sign(obj);
        // Passing the object across untrusted boundary
        signatureService.Validate(obj);
    }
}

class Program
    {
        static void Main(string[] args)
        {
            MainAsync(args).GetAwaiter().GetResult();

            Console.ReadKey();
        }

        static async Task MainAsync(string[] args)
        {
            HardWorker hardWorker1 = new HardWorker();
            HardWorker hardWorker2 = new HardWorker();
            HardWorker hardWorker3 = new HardWorker();
            HardWorker hardWorker4 = new HardWorker();
            HardWorker hardWorker5 = new HardWorker();

            Task t1 = Task.CompletedTask;
            Task t2 = Task.CompletedTask;
            Task t3 = Task.CompletedTask;
            Task t4 = Task.CompletedTask;
            Task t5 = Task.CompletedTask;

            Random rand = new Random();

            for (int i = 0; i < 50; i++)
            {
                t1 = t1.ContinueWith(task => hardWorker1.DoSomething(1, rand.Next(1, 10000)));
                t2 = t2.ContinueWith(task => hardWorker2.DoSomething(2, rand.Next(1, 10000)));
                t3 = t3.ContinueWith(task => hardWorker3.DoSomething(3, rand.Next(1, 10000)));
                t4 = t4.ContinueWith(task => hardWorker4.DoSomething(4, rand.Next(1, 10000)));
                t5 = t5.ContinueWith(task => hardWorker5.DoSomething(5, rand.Next(1, 10000)));
            }

            await Task.WhenAll(t1, t2, t3, t4, t5);
        }
    }

    public class HardWorker : AbstractHardWorker
    {
        public void DoSomething(int task, int time)
        {
            Console.Out.WriteLine("Start: " + task);
            Thread.Sleep(time);
            Console.Out.WriteLine("End: " + task);
        }
    }

    public interface AbstractHardWorker
    {
        void DoSomething(int task, int time);
    }

Самый популярный инструмент для этого - ILMerge. Есть в виде nuget-пакета, и может выполняться во время билда.