using System;
using System.IO;

namespace ConsoleApp1 {
    class Program {
        static void Main(string[] args) {
            var logger = new MyLogger<Exception>();
            IWriteable<Exception> logger2 = new MyLogger2<Exception>();

            var reader = new MyReader<decimal>();
            var writer = new MyWriter<string>();
        }
    }

    interface IReadable<out T> {
        T Read(Stream s);
    }

    interface IWriteable<in T> {
        void Write(Stream s, T data);
    }

    interface ILogger<T> : IReadable<T>, IWriteable<T> { }

    class MyLogger<T> : ILogger<T> {
        public T Read(Stream s) {
            throw new NotImplementedException();
        }

        public void Write(Stream s, T data) {
            throw new NotImplementedException();
        }
    }

    class MyLogger2<T> : IReadable<T>, IWriteable<T> {
        public T Read(Stream s) {
            throw new NotImplementedException();
        }

        public void Write(Stream s, T data) {
            throw new NotImplementedException();
        }
    }

    class MyReader<T> : IReadable<T> {
        public T Read(Stream s) {
            throw new NotImplementedException();
        }
    }

    class MyWriter<T> : IWriteable<T> {
        public void Write(Stream s, T data) {
            throw new NotImplementedException();
        }
    }

    abstract class MyAbstractLogger<T> : ILogger<T> {
        public T Read(Stream s) {
            try {
                return (T)new XmlSerializer(typeof(T)).Deserialize(s);
            } catch (Exception) {
                throw;
            }
        }

        public void Write(Stream s, T data) {
            try {
                new XmlSerializer(typeof(T)).Serialize(s, data);
            } catch (Exception) {
                throw;
            }
        }
    }

    class MyExceptionLogger : MyAbstractLogger<Exception> {

    }

    class MyStringLogger : MyAbstractLogger<string> {

    }
}