Useful C# Snippets

Some useful snippets collected during my work with C#, UWP, and .NET.

Load HTML from app into WebView

The HTML and other resources should be inside the Assets/web folder in the project, and the files should be marked as Content in the properties.

webView.Navigate(new System.Uri("ms-appx-web:///Assets/web/index.html"));

Read JSON from local resources

var json = File.ReadAllText("Assets/file.json");

Message box dialog

Of course the surrounding method should be async.

using Windows.UI.Popups;
var dialog = new MessageDialog(seat);
await dialog.ShowAsync();

C# Listen to file changes


using System;
using System.IO;
using System.Runtime.Loader;
using System.Threading.Tasks;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Primitives;

namespace CAL.Daemon
    class Program
        static PhysicalFileProvider fileProvider = new PhysicalFileProvider(Directory.GetCurrentDirectory());

        static void Main(string[] args)
            //register sigterm event handler
            AssemblyLoadContext.Default.Unloading += SigTermEventHandler;

            //register sigint event handler
            Console.CancelKeyPress += CancelHandler;

            Console.WriteLine("Monitoring quotes.txt for changes (Ctrl-c to quit)...");

            while (true)

        static async Task MainAsync()
            IChangeToken token = fileProvider.Watch("quotes.txt");
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();

            token.RegisterChangeCallback(state =>
                var info = fileProvider.GetFileInfo("quotes.txt");
                var date = info.LastModified;
                var length = info.Length;
                Console.WriteLine($"last modified: { date} ({ length})");
            } , tcs);

            await tcs.Task.ConfigureAwait(false);

            Console.WriteLine("quotes.txt changed");

        static void SigTermEventHandler(AssemblyLoadContext obj)

        static void CancelHandler(object sender, ConsoleCancelEventArgs e)

Lock multithreaded access to method

For example to avoid several threads writing the same contents to the same file.

private static readonly object locker = new object();

lock (locker)
    string text;
    using (var stream = new MemoryStream())
        var s = new DataContractJsonSerializer(typeof(Cls));
        s.WriteObject(stream, obj);
        text = Encoding.UTF8.GetString(stream.ToArray());
    File.WriteAllText(file.Path, text);

Invoke JavaScript on WebView

The interface for InvokeScriptAsync() takes only strings and returns only strings. Of course the surrounding method should be async.

var message = "something";
string[] data = { message };
await webView.InvokeScriptAsync("js_function_name", data);

Deep cloning in C#


public interface IDeepCloneable
    object DeepClone();

public interface IDeepCloneable<T> : IDeepCloneable
    T DeepClone();

public class SampleClass : IDeepCloneable<SampleClass>
    public SampleClass DeepClone()
        // Deep clone your object
        return ...;

    object IDeepCloneable.DeepClone()
        return this.DeepClone();

Generating XML file using XSD file


<?xml version="1.0"?>
<xs:schema xmlns:xs="">
  <xs:element name="MyClass">
        <xs:element name="Field1"
        <xs:element name="Field2"

You can use this even on Mac:

xsd.exe /classes Test.xsd

using System.Xml.Serialization;
// ...
var data = new MyClass { Field1 = "test1", Field2 = "test2" };
var serializer = new XmlSerializer(typeof(MyClass));
using (var stream = new StreamWriter("C:\\test.xml"))
    serializer.Serialize(stream, data);


<?xml version="1.0" encoding="utf-8"?>
<MyClass xmlns:xsd="" xmlns:xsi="">

Deserializing XML into objects

XmlSerializer serializer = new XmlSerializer(typeof(SegmentSeatMap));
string xml = File.ReadAllText("file.xml");

SegmentSeatMap seatmap = null;
using (TextReader r = new StringReader(xml))
    seatmap = (SegmentSeatMap)serializer.Deserialize(r);

Another option

XmlSerializer serializer = new XmlSerializer(typeof(SegmentSeatMap));
string path = "file.xml";
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
SegmentSeatMap obj = (SegmentSeatMap)serializer.Deserialize(fs);

More advanced, when the classes to deserialize are marked as [DataContract]

string xml = File.ReadAllText("file.xml");
DataContractSerializer serializer = new DataContractSerializer(typeof(SegmentSeatMap));
SegmentSeatMap obj = null;
using (XmlReader r = XmlReader.Create(new StringReader(xml)))
    obj = (SegmentSeatMap)serializer.ReadObject(r);

Reading the SOAP message

// Adapted from
Message m = Message.CreateMessage(XmlReader.Create(path), int.MaxValue, MessageVersion.Soap11);
SoapReflectionImporter importer = new SoapReflectionImporter(new SoapAttributeOverrides(), "");
XmlTypeMapping mapp = importer.ImportTypeMapping(typeof(ResponseBase));
XmlSerializer xmlSerializer = new XmlSerializer(mapp);
XmlDictionaryReader reader = m.GetReaderAtBodyContents();
ResponseBase obj = (ResponseBase)xmlSerializer.Deserialize(reader);
return obj;

C# Dynamic Object Created at Runtime


public class DynamicClass : DynamicObject
    private Dictionary<string, KeyValuePair<Type, object>> _fields;

    public DynamicClass(List<Field> fields)
        _fields = new Dictionary<string, KeyValuePair<Type, object>>();
        fields.ForEach(x => _fields.Add(x.FieldName,
            new KeyValuePair<Type, object>(x.FieldType, null)));

    public override bool TrySetMember(SetMemberBinder binder, object value)
        if (_fields.ContainsKey(binder.Name))
            var type = _fields[binder.Name].Key;
            if (value.GetType() == type)
                _fields[binder.Name] = new KeyValuePair<Type, object>(type, value);
                return true;
            else throw new Exception("Value " + value + " is not of type " + type.Name);
        return false;

    public override bool TryGetMember(GetMemberBinder binder, out object result)
        result = _fields[binder.Name].Value;
        return true;

public class Field
    public Field(string name, Type type)
        this.FieldName = name;
        this.FieldType = type;

    public string FieldName;

    public Type FieldType;

var fields = new List<Field>() {
    new Field("EmployeeID", typeof(int)),
    new Field("EmployeeName", typeof(string)),
    new Field("Designation", typeof(string))

dynamic obj = new DynamicClass(fields);

obj.EmployeeID = 123456;
obj.EmployeeName = "John";
obj.Designation = "Tech Lead";

obj.Age = 25;             //Exception: DynamicClass does not contain a definition for 'Age'
obj.EmployeeName = 666;   //Exception: Value 666 is not of type String

Console.WriteLine(obj.EmployeeID);     //123456
Console.WriteLine(obj.EmployeeName);   //John
Console.WriteLine(obj.Designation);    //Tech Lead

XmlSerializer UTF-8

By default, the StringReader class processes everything as UTF-16; to do it in UTF-8, use this subclass:

c# - Serializing an object as UTF-8 XML in .NET - Stack Overflow

public class Utf8StringWriter : StringWriter
    public override Encoding Encoding => Encoding.UTF8;

    public Utf8StringWriter(StringBuilder str) : base(str){}

Use it like this:

var serializer = new XmlSerializer(typeof(ClassToSerialize));
var str = new StringBuilder();
using (var stream = new Utf8StringWriter(str))
    using (var xmlWriter = XmlWriter.Create(stream, new XmlWriterSettings { Indent = false }))
        serializer.Serialize(xmlWriter, data);
Console.WriteLine(str.Replace("\"", "\\\""));

Note the Indent = false to configure yet another factor of the final XML.