Skip to content

@hodzanassredin /DesignByContract.cs
Created

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Design By contract with types in runtime in c#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TypesContracts
{
class Program
{
static void Main(string[] args)
{
string s = Size(null);//result: argument exception
Console.WriteLine(Lenght(null));//result 0
DivByZero(0);// result: argument exception
Log(5);//result: log 5 to console
AddTenSymbols("");//result: if result string has lenght more than 10 then log result string/
Console.ReadKey();
}
static Check<string, IsNotNull<string>> Size(Check<object, IsNotNull<object>> obj)
{
return obj.ToString();
}
static int Lenght(Check<string, AndReplaceByEmptyIfNull> str)
{
string stri = str;
return stri.Length;
//return ((string)str).Length;
}
static int DivByZero(Check<int, If<int, EqualsTo<Zero>, ThenThrowArgumentException<int>>> i)
{
return 1 / i;
}
static Check<int, If<int, BothTrue<Not<EqualsTo<Zero>>, Not<MoreThan<Ten>>>, ThenLog<int>>> Log(int i)
{
return i;
}
static Check<string, If<string, Member<string, int, StringLenght, MoreThan<Ten>>, ThenLog<string>>> AddTenSymbols(string s)
{
return s + "asffgsdfgd"; ;
}
}
public struct Check<T, U> where U : Constraint<T>, new()//we cant create shortcurs for struct or maybe we can?
{
private T _val;
public Check(T val)
{
_val = new U().CheckAndReturn(val);
}
public static implicit operator T(Check<T, U> d)
{
return d._val;
}
public static implicit operator Check<T, U>(T d)
{
return new Check<T, U>(d);
}
public T Val { get { return _val; } }
public override string ToString()
{
return _val.ToString(); // or we can throw exception
}
public override bool Equals(object obj)
{
return _val.Equals(obj);
}
public override int GetHashCode()
{
return _val.GetHashCode();
}
}
public abstract class Constraint<T>
{
public abstract T CheckAndReturn(T inp);
}
public class IsNotNull<T> : Constraint<T> where T : class
{
public override T CheckAndReturn(T inp)
{
if (inp == null) throw new ArgumentException("bl a bla");
return inp;
}
}
public class DefaultInsteadOfNull<T> : Constraint<T> where T : class, new()//doesnt work with string coz str doesnt have empty ctor
{
public override T CheckAndReturn(T inp)
{
if (inp == null) throw new ArgumentException("bl a bla");
return inp == null ? new T() : inp;
}
}
public class AndReplaceByEmptyIfNull : Constraint<String>//string doesnt have empty ctor
{
public override String CheckAndReturn(String inp)
{
return inp == null ? String.Empty : inp;
}
}
//more cool stuff
public class If<T, C, D> : Constraint<T>
where C : Compare<T>, new()
where D : Then<T>, new()
{
public override T CheckAndReturn(T inp)
{
var comp = new C();
if (comp.DoComparison(inp)) new D().Do(inp);
return inp;
}
}
public abstract class Value<V>
{
private V _val;
public Value(V val)
{
_val = val;
}
public V Get()
{
return _val;
}
}
public abstract class Compare<T>
{
public abstract bool DoComparison(T val1);
}
public abstract class Getter<T, U>
{
public abstract U Get(T val1);
}
public class StringLenght : Getter<String, int>
{
public override int Get(string val1)
{
return val1.Length;
}
}
public class Member<VALUE, SELECTEDVALUE, GETTER, COMPARER> : Compare<VALUE>
where GETTER : Getter<VALUE, SELECTEDVALUE>, new()
where COMPARER : Compare<SELECTEDVALUE>, new()
{
public override bool DoComparison(VALUE val1)
{
var getter = new GETTER();
var comparer = new COMPARER();
return comparer.DoComparison(getter.Get(val1));
}
}
public abstract class Then<T>
{
public abstract void Do(T inp);
}
public class ThenThrowArgumentException<T> : Then<T>
{
public override void Do(T inp)
{
throw new ArgumentException("");
}
}
public class ThenLog<T> : Then<T>
{
public override void Do(T inp)
{
Console.WriteLine(inp.ToString());
}
}
public class Zero : Value<int> { public Zero() : base(0) { } }
public class One : Value<int> { public One() : base(1) { } }
public class Ten : Value<int> { public Ten() : base(10) { } }
public class MoreThan<V> : Compare<int> where V : Value<int>, new()
{
public override bool DoComparison(int val1)
{
var v = new V();
return val1 > v.Get();
}
}
public class LessThan<V> : Compare<int> where V : Value<int>, new()
{
public override bool DoComparison(int val1)
{
var v = new V();
return val1 < v.Get();
}
}
public class EqualsTo<V> : Compare<int> where V : Value<int>, new()
{
public override bool DoComparison(int val1)
{
var v = new V();
return val1 == v.Get();
}
}
public class BothTrue<C1, C2> : Compare<int>
where C1 : Compare<int>, new()
where C2 : Compare<int>, new()
{
public override bool DoComparison(int val1)
{
var c1 = new C1();
var c2 = new C2();
return c1.DoComparison(val1) && c2.DoComparison(val1);
}
}
public class Not<C1> : Compare<int>
where C1 : Compare<int>, new()
{
public override bool DoComparison(int val1)
{
var c1 = new C1();
return !c1.DoComparison(val1);
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.