Fozzy.System by www.homethic.com

<PackageReference Include="Fozzy.System" Version="1.2.3.3" />

---

API Diff between 1.2.3.3 and 1.2.3.93

1796 Additions 523 Removals

Fozzy

• public static class __Be
  • public static IEnumerable<Property> Be(this IEnumerable<Property> objects, Type type)
  • public static IEnumerable<Property> Be(this IEnumerable<Property> objects, _Type type)
• public class _<type> : IValue<type>, IObject, IBe<object>, IBe, IChanged
• public class _Element : XElement, IName, IBe, IRoot, IDisposable
  • public IEnumerable<XAttribute> Attributes { get; }
  • public bool Be_Empty { get; }
  • public bool Be_Error { get; }
  • public byte[] Bytes { get; }
  • public _Element Default { get; }
  • public Directory Directory { get; }
  • public _Element Element { get; }
  • public virtual Extension Extension { get; }
  • public bool Have_Identifier { get; }
  • public bool Have_Name { get; }
  • public _Type I { get; }
  • public Identifier Identifier { get; }
  • public Name Name { get; }
  • public string String { get; }
  • public Template Template { get; }
  • public Type Type { get; }
  • public _Element()
  • public _Element(string name)
  • public _Element(Type type)
  • public _Element(IName e1, IName e2)
  • public _Element(_Element element, Name name)
  • public _Element(_Element e1, _Element e2)
  • public _Element(nature nature, _Element e2)
  • public _Element(string name, Type type)
  • public _Element(Type window, Directory dir)
  • public _Element(Type window, string name, Directory dir)
  • public _Element(Type window, Resource resource, Directory dir)
  • public _Element(Directory dir)
  • public _Element(Directory dir, string name)
  • public _Element(object instance)
  • public _Element(Name name, IName first)
  • public _Element(Name name, IName first, IName second)
  • public _Element(Name name, IName first, IName second, IName third)
  • public _Element(_Element element, IName first)
  • public _Element(_Element element, IName first, IName second)
  • public _Element(_Element element, IName first, IName second, IName third)
  • public name Activater<name>()
  • public void Add(Name name)
  • public void Add(Identifier id)
  • public void Add(IEnumerable<_Element> elements)
  • public void Add(_Element element)
  • public XAttribute Attribute(Name parameter)
  • public XAttribute Attribute(nature attribute)
  • public bool Be(string value)
  • public bool Be(string name, string value)
  • public bool Be(object target)
  • public IEnumerable<type> Concepts<type>() where type : IConcept
  • public void Dispose()
  • public IEnumerable<_Element> Elements()
  • public IEnumerable<_Element> Elements(string name)
  • public IEnumerable<_Element> Elements(Name name)
  • public IEnumerable<_Element> Elements(nature element)
  • public bool Exist(string parameter)
  • public type Get<type>(string property) where type : IConcept
  • public IEnumerable<_Element> Get(string name)
  • public string Instance(string name)
  • public _Element Local(string parameter)
  • public IEnumerable<_Element> Locals(XAttribute attribute)
  • public IEnumerable<_Element> Locals(string attribute)
  • public void Set(Name name)
  • public void Set<type>(Many<type> manys)
  • public void Set<type>(IName concept)
  • public void Set(Extension extension)
  • public void Set(Directory dir)
  • public void Stamp()
  • public XElement XElement(string name)
  • public XElement XElement(nature element)
  • public XElement XElement(XName name)
  • public XElement XElement(XAttribute name)
• public static class _Execute
  • public static void Execute(this IEnumerable<IConcept> Objects)
  • public static void Execute(this IEnumerable<IConcept> Objects, method method)
• public class _Object<e1, e2> : Concept<Tuple<e1, e2>, IName>
  • public virtual bool Be_Error { get; }
  • public e1 First { get; }
  • protected bool Have_Second { get; }
  • public object Instance { get; }
  • public e2 Second { get; }
  • public _Object(e1 s1, e2 s2)
  • public _Object(Name name, e1 s1, e2 s2)
  • protected virtual void Change(e2 from, e2 to)
  • public virtual void Set(e1 value)
  • public virtual void Set(e2 value)
  • protected void Set(e1 first, e2 second)
• public class _Properties : Enumeration<Property>
  • public IEnumerable<Property> Changers { get; }
  • public IEnumerable<Property> Dependencies { get; }
  • public IEnumerable<Property> Functionals { get; }
  • public IEnumerable<Property> Keys { get; }
  • public NameSpace NameSpace { get; }
  • public IEnumerable<Property> Sources { get; }
  • public IEnumerable<Property> States { get; }
  • public _Properties(Type type)
  • public _Properties(IEnumerable<Property> properties)
  • public _Properties(string content, string parser, IConcept target)
  • public Property Property(string name)
  • public Property Property(property prop)
  • public void Set(object target, IEnumerable<string> names, IEnumerable<object> values)
• public class _Stream : _Object<Stream, direction>
  • protected bool At_End { get; }
  • protected Buffer Buffer { get; }
  • public byte[] Bytes { get; }
  • public Integer Length { get; }
  • public long Position { get; }
  • protected Reader Reader { get; }
  • public Stream Stream { get; }
  • public string Value { get; }
  • protected _Writer Writer { get; }
  • public _Stream(FileStream stream)
  • public _Stream(Stream stream)
  • public _Stream(Stream stream, direction dir)
  • public _Stream(Reader reader)
  • public void Close()
  • public void Copy(_Stream target)
  • public void Flush()
  • public void Move(long pos)
  • protected int Read()
  • public void Save()
  • public void Write_Bytes()
  • public void Write_String()
• public class _System<part> : OneN<Base<part>, ISkill>, IName, IBe, IRoot, IDisposable where part : IName
  • protected Assembly Assembly { get; }
  • public virtual Directory Directory { get; }
  • public _Element Element { get; }
  • public part First_Part { get; }
  • public part Fourth_Part { get; }
  • public Name Full_Name { get; }
  • public Identifier Identifier { get; }
  • public Name Name { get; }
  • public NameSpace NameSpace { get; }
  • protected method Natural_Method { get; }
  • public Enumeration<part> Parts { get; }
  • public part Second_Part { get; }
  • public IEnumerable<string> Strings { get; }
  • public part Third_Part { get; }
  • public _Type Type { get; }
  • public _System()
  • public _System(Name name)
  • public _System(int max)
  • public _System(part part)
  • public _System(part part1, part part2)
  • public _System(part part1, part part2, part part3)
  • public _System(Name name, part part)
  • public _System(IEnumerable<part> parts)
  • public _System(_Element element)
  • public void Add(part part)
  • public void Add(IEnumerable<part> parts)
  • public bool Be(IName name)
  • public void Delete(part part)
  • public void Execute(IConcept target)
  • public void Prefixe(Template template)
  • public IEnumerable<Property> Properties()
  • public Property Property(Name name)
  • public Property Property(string name)
  • public Property Property(property prop)
  • public Property Property(_Type type)
  • protected virtual void Skillise()
  • public void Suffixe(Template template)
• public class _Time : Pattern<IName>
  • public _Time(Name source)
• public class _Type : Tuple<Type>, IName, IBe, IRoot, IDisposable, IValue<Type>
  • public Alias Alias { get; }
  • public Assembly Assembly { get; }
  • public Type Base_Type { get; }
  • public bool Be_Active { get; }
  • public bool Be_Boolean { get; }
  • public bool Be_Concept { get; }
  • public bool Be_Constructible { get; }
  • public bool Be_Empty { get; }
  • public bool Be_Enumeration { get; }
  • public bool Be_Error { get; }
  • public bool Be_Of_Int { get; }
  • public bool Be_Of_String { get; }
  • public bool Be_Our { get; }
  • public IEnumerable<Type> Brothers { get; }
  • public Capacities Capacities { get; }
  • public IEnumerable<Property> Changers { get; }
  • public Constructor Constructor { get; }
  • public Constructors Constructors { get; }
  • public Type Default { get; }
  • public IEnumerable<Property> Dependencies { get; }
  • public IEnumerable<Type> Deriveds { get; }
  • public Directory Directory { get; }
  • public _Element Element { get; }
  • public IEnumerable<_Element> Elements { get; }
  • public _Type Father { get; }
  • public IEnumerable<Property> Functionals { get; }
  • public bool Have_Sons { get; }
  • public _Type I { get; }
  • public object Instance { get; }
  • public IEnumerable<Type> Interfaces { get; }
  • public IEnumerable<Property> Keys { get; }
  • public Constructor Main_Constructor { get; }
  • public Methods Methods { get; }
  • public Name Name { get; }
  • public NameSpace NameSpace { get; }
  • public method Natural_Method { get; }
  • public string String { get; }
  • public object Target { get; }
  • public Template Template { get; }
  • public Type Type { get; }
  • public Type Value { get; }
  • public _Type(string type)
  • public _Type(Type type)
  • public static _Type op_Implicit(Type type)
  • public object Activator(object[] parameters)
  • public object Activator(object parameter)
  • public object Activator(string parameter)
  • public object Activator()
  • public target Activator<target>()
  • public object Attribute<att>() where att : XAttribute
  • public XAttribute Attribute()
  • public IEnumerable<Attribute> Attributes(_Type type)
  • public bool Be(string other)
  • public bool Be(Type other)
  • public bool Be(object target)
  • public bool Be<type>()
  • public bool Be_Son(_Type father)
  • public Property Capacity(Name name)
  • public void Dispose()
  • public void Execute(IName target, method method)
  • public void Execute(IName target, string method)
  • public bool Exposes(method method)
  • public object Get(property property)
  • public bool Implements(_Type interf)
  • public bool Implements(Type inter)
  • public Interface Interface(Type type)
  • public Interface Interface(_Type type)
  • public Method Method(string name)
  • public Method Method(Name name)
  • public Method Method(method name)
  • public Property Property(string name)
  • public Property Property(property prop)
  • public Property Property(Name prop)
  • public void Set(property property, object target, object value)
  • public void Stamp()
  • public Status Status(Name name)
• public class _Writer : Skill<_Stream, File>
  • public Stream Stream { get; }
  • public _Writer()
  • public _Writer(Stream stream)
  • public _Writer(Name name)
  • public void Close()
  • public void Copy(_Stream target)
  • public void Delete()
  • public void Execute(Stream target)
  • public void Execute(Buffer buffer)
  • public void Write(Name name)
  • public void Write(_Stream stream)
  • public void Write(_Element element)
• public class Absolute : Uri
  • public Absolute(string directory, Uri extension)
  • public Absolute(Directory directory, Uri extension)
• public class Accesser : Enumeration<IName>
  • public Document Document { get; }
  • public _Stream Stream { get; }
  • public Accesser(string fullname)
• public static class Activate
  • public static entity Activator<entity>(object[] parameters)
  • public static IEnumerable<entity> Activator<entity>(this IEnumerable<object> sources) where entity : IName
  • public static entity Activator<entity>(string parameter)
  • public static entity Activator<entity>(Element element)
  • public static entity Activator<entity>(object[] parameters)
  • public static entity Activator<entity>(_Element element)
  • public static object Activator(string name)
  • public static object Activator(Type type)
  • public static object Activator(_Type type)
• public class Active<type> : One_Many<type, Element> where type : IName
• public class Addition<operand> : Transitive<operand>
  • public Addition(Element element)
  • public Addition(_Element element)
• public class Alias : Concept<Type, IName>
  • public Alias(string name)
• public abstract class All<alt> : Many<alt>
• public class Anonymous : Complement
• public abstract class Archetype<iname, iconcept> : Many<iconcept> where iname : IOne where iconcept : IOne
• public class And : CBoolean
  • public And(string name, verb verb, IConcept concept)
• public class Arguments : EventArgs
  • public Element Element { get; }
  • public Structure Form { get; }
  • public _Element Element { get; }
  • public Form Form { get; }
  • public object Parameter { get; }
  • public object Value { get; }
  • public Arguments(string name, Element element)
  • public Arguments(string name, _Element element)
  • public bool Be(Element element)
  • public bool Be(_Element element)
• public class Assembly : OneN<Assembly, Type>
  • public Assembly(Type type)
  • public Assembly(Assembly assembly)
  • public Assembly(_Type type)
  • public Stream Stream(Name file)
  • public Stream Stream(string file)
  • public _Stream Stream(Name file)
  • public _Stream Stream(string file)
• public class Attribute : One<Attribute>
• public class Attribute<attribute> : Concept<attribute, IName> where attribute : Attribute
  • public Attribute(_Type target)
  • public Attribute(object[] attributes)
• public class Attributes : Reflection<Attribute, Attribute>
• public class BackSlashZero : Chunk
• public class Base<part> : OneN<_Element, part>, IBase, IName, IBe, IRoot, IDisposable, IExtend, IClean where part : IName
  • public virtual _Element Element { get; }
  • public part First_Part { get; }
  • public part Fourth_Part { get; }
  • public string Full_Name { get; }
  • protected bool Have_Element { get; }
  • public Identifier Identifier { get; }
  • public Name Name { get; }
  • public virtual Enumeration<part> Parts { get; }
  • public part Second_Part { get; }
  • public string String { get; }
  • public IEnumerable<string> Strings { get; }
  • public part Third_Part { get; }
  • public _Type Type { get; }
  • public Base()
  • public Base(Name name)
  • public Base(int max)
  • public Base(part part1)
  • public Base(part part1, part part2)
  • public Base(part part1, part part2, part part3)
  • public Base(Name name, part part1)
  • public Base(IEnumerable<part> parts)
  • public Base(_Element element)
  • public bool Be(IName other)
  • public void Clean()
  • public void Prefixe(Template template)
  • public IEnumerable<Property> Properties()
  • public IEnumerable<Property> Properties(IEnumerable<string> names)
  • public Property Property(Name name)
  • public Property Property(string name)
  • public Property Property(property prop)
  • public Property Property(_Type type)
  • protected virtual void Skillise()
  • public void Suffixe(Template template)
• public class Binary_Reader : Concept<BinaryReader, Integer>
  • public byte Byte { get; }
  • public Binary_Reader(_Stream stream)
  • public Binary_Reader(BinaryReader reader, Integer length)
• public class Boolean : Exhaustive<bool>
  • public Boolean(IName received)
• public class Buffer : Get<byte[]>
  • public Buffer(long number)
  • public Buffer(int number)
  • public Buffer(Integer number)
  • public void Copy(Stream target)
  • public void Copy(_Stream target)
• public class Byte : Get<byte>
  • protected virtual bool Be_Localised { get; }
  • protected Culture Culture { get; }
  • public Byte(string reader)
  • public Byte(Name name)
• public class Capture : Name
• public class Capacity : Tuple<Boolean, Boolean>
  • protected Boolean Doable { get; }
  • protected Boolean Done { get; }
  • public Capacity()
  • public Capacity(bool value)
  • public virtual void Execute(IEnumerable<Complement> comps)
• public class Character : Get<char>
• public class Chunk : List<String>
• public class Client : Container<WebClient>
• public class CBoolean : Sentence
  • public Boolean Value { get; }
  • public CBoolean(string properties, string parser, verb verb, IConcept concept)
  • public CBoolean(Subject subject)
• public class Char : Get<char>
  • public Char(BinaryReader reader)
• public class Cleaner : Skill<object, IConcept>
  • public Cleaner(bool clean, IConcept target)
• public class Cod : Complement
  • public Cod(Exception ex, Type type)
  • public Cod(Type type)
  • public Cod(Exception ex)
  • public Cod(_Type type)
• public class Collection<collection, instance, part> : Many<part> where collection : ICollection where part : IOne
• public enum complement
  • Time = 3
• public class Complement : Concept<complement, IName>
  • public complement Nature { get; }
• public class Concept : Plural<IOne>
• public class Concept<value, name> : OneN<_System<name>, IRelation>, IConcept<value, name>, IConcept<name>, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable, IPartable<name>, IValue<value>, IChanged, IEquatable<IConcept>, IAbility, IRelational, IElement, IIdentifier, IWhere<name> where name : IName
  • public virtual bool Be_Complete { get; }
  • public virtual bool Be_Empty { get; }
  • public virtual bool Be_Error { get; }
  • public bool Be_Null { get; }
  • protected virtual Directory Directory { get; }
  • protected virtual Extension Extension { get; }
  • public name Current { get; }
  • public virtual value Default { get; }
  • public virtual bool Exists { get; }
  • protected bool Have_File { get; }
  • public event Handler Event
  • protected value First { get; }
  • protected name First_Part { get; }
  • protected ISkill First_Skill { get; }
  • protected name Fourth_Part { get; }
  • protected bool Have_Parts { get; }
  • public bool Have_Value { get; }
  • public _Type I { get; }
  • public Identifier Identifier { get; }
  • public virtual IEnumerable<name> Instances { get; }
  • public IRelation Last_Relation { get; }
  • public virtual Name Name { get; }
  • public virtual IEnumerable<Name> Names { get; }
  • public Enumeration<name> Parts { get; }
  • protected virtual Template Prefix { get; }
  • protected Reader Reader { get; }
  • protected name Second_Part { get; }
  • protected ISkill Second_Skill { get; }
  • protected IEnumerable<ISkill> Skills { get; }
  • public object Source { get; }
  • protected virtual Template Suffix { get; }
  • protected name Third_Part { get; }
  • protected ISkill Third_Skill { get; }
  • public value Value { get; }
  • protected virtual string XName { get; }
  • public event Handler Event_Changed
  • public Concept(value source, int max)
  • public Concept(Type type)
  • public Concept(string name)
  • public Concept(object target)
  • public Concept(string name, object target)
  • public Concept(value value, CultureInfo culture)
  • public Concept(value value, object target)
  • public Concept(Element element)
  • public Concept(string name, value value)
  • public Concept(value value, part part1)
  • public Concept(part part1, part part2)
  • public Concept(value value, part part1, part part2)
  • public Concept(value value, part part1, part part2, part part3)
  • public Concept(part part)
  • public Concept(IEnumerable<part> parts)
  • public Concept(value value, IEnumerable<part> parts)
  • protected virtual void Add(Element element)
  • public virtual bool Be(IOne target, object selection)
  • public void Browse(Handler handler)
  • protected void Browse(Order order)
  • public void Browse(Handler handler, Arguments argument)
  • protected void Change(method method)
  • public Concept(File file)
  • public Concept(object parameter)
  • public Concept(Name name, object parameter)
  • public Concept(_Element element)
  • public Concept(Name name)
  • public Concept(Name name, Identifier identifier)
  • public Concept(Name name, value source)
  • public Concept(string name)
  • public Concept(name part)
  • public Concept(value source, name part)
  • public Concept(Name name, value source, name part)
  • public Concept(value source, IEnumerable<name> parts)
  • public Concept(Name name, Directory dir, value source)
  • public Concept(Name file, Directory dir)
  • public Concept(Directory dir, File file)
  • public Concept(value source, name part1, name part2)
  • public Concept(name part1, name part2)
  • public Concept(IEnumerable<name> parts)
  • public virtual void Add(name part)
  • public virtual void Add(IEnumerable<name> parts)
  • public void Add(_Element element)
  • protected void Add(ISkill skill)
  • protected void Add(IRelation relation)
  • protected virtual void Add_Property(IConcept sender, Arguments args)
  • public bool Adjective(string name)
  • public bool Adjective(Name name)
  • public virtual bool Be(IConcept other)
  • public bool Be(IName name)
  • public virtual bool Be(object name)
  • public virtual bool Be(value entity)
  • public virtual bool Be(IConcept target, object selection)
  • public virtual bool Be_Current(string other)
  • public virtual bool Be_Invariant(string other)
  • protected virtual void Change_Occured(object sender, Arguments args)
  • protected virtual void Default_Parts()
  • protected virtual void Default_Value()
  • public virtual void Delete(name part)
  • public virtual void Dispose()
  • protected void Dispose(object target)
  • protected virtual void Dispose(bool disposeManagedResources)
  • protected bool Ends_With(string test)
  • public virtual void Execute(object method)
  • protected virtual void Learn(object target, Arguments arguments)
  • public void Execute(method method)
  • public void Execute(string method)
  • public void Execute(IName target, method method)
  • protected void Extend(string addition)
  • protected virtual void Fail(Exception ex)
  • protected virtual void Fail()
  • protected virtual void Finish()
  • public bool Have(string properties)
  • protected virtual void Inform()
  • protected virtual void Inform(object sender, EventArgs args)
  • public void Inform_Properties()
  • protected virtual void Initialise()
  • public virtual name Instance(Name name)
  • public virtual name Instance(IName name)
  • protected name Instance(int i)
  • protected virtual void Instancise()
  • protected virtual void Interface()
  • public bool Like(IConcept other)
  • protected virtual void Live()
  • protected void Positione(int i)
  • public IEnumerable<son> Nexts<son>(property next) where son : IConcept
  • protected virtual void Pre_Value()
  • public void Prefixe(Template prefix)
  • public IEnumerable<Property> Properties(IEnumerable<string> names)
  • public IEnumerable<Property> Properties()
  • public Property Property(string name)
  • public Property Property(property prop)
  • public Property Property(_Type type)
  • protected virtual void Re_Name()
  • protected virtual void Re_Name(_Type type)
  • public virtual void Re_Set()
  • protected void Re_Set(string name)
  • protected virtual void Re_Source()
  • protected virtual void Re_Value()
  • protected virtual void Relate()
  • public virtual void Relate(IName part, int i)
  • public virtual void Relate(IConcept owner)
  • public virtual void Relate(IRelation relation)
  • protected IEnumerable<concept> Relations<concept>(object val) where concept : IConcept
  • protected IEnumerable<concept> Relations<concept>(string val) where concept : IConcept
  • public Enumeration<IRelation> Relations()
  • public void Remove(name part)
  • protected void Rename(int pos, string part)
  • public void Replace(IRelation relation)
  • protected virtual void Save(File file)
  • protected void Send(error error, method method)
  • protected void Send(warning warning, method method)
  • protected void Send(method method, object parameter)
  • public void Set(IEnumerable<part> parts)
  • public void Set(part part)
  • protected virtual void Select(object sender, Arguments arguments)
  • protected void Select(int i)
  • protected virtual void Selection_Occured(object sender, Arguments args)
  • public virtual void Set(value value)
  • protected void Set(Identifier identifier)
  • protected void Set(Extension extension)
  • protected void Set(Directory dir)
  • protected virtual void Start()
  • protected bool Starts_With(string test)
  • protected virtual void Subscribe(IConcept source)
  • public void Suffixe(Template suffix)
  • public void Swap(IConcept target)
  • protected void Switch(name part1, name part2)
  • protected virtual void Upgrade()
  • public virtual IEnumerable<name> Where(object parameter)
• public class Concepts<type> : Enumeration<type> where type : IConcept
  • public Concepts(IEnumerable<Element> instances)
  • public Concepts(IEnumerable<_Element> instances)
• public class Constructor : Concept<ConstructorInfo, IName>
  • public bool Be_ParameterLess { get; }
  • public bool Without_Parameters { get; }
• public class Constructors : Enumeration<Constructor>
  • public Constructor Parameterless { get; }
  • public Constructor No_Parameters { get; }
• public class Container<value> : One<value>
• public class Crease<operand> : Transitive<operand>
  • public Crease(Element element)
  • public Crease(_Element element)
• public class Culture : Concept<CultureInfo, IName>
  • public string Lower { get; }
  • public Culture()
  • public Culture(string name, CultureInfo cInfo)
  • public Culture(CultureInfo cInfo)
  • public Name Lower { get; }
  • public Culture(Name name, CultureInfo cInfo)
• public class Culture_Template<format> : Name where format : IFormattable
• public class Current : Culture
  • public Current()
• public class Default : Element
• public class Date_Selection : Selection<string>
  • public Date_Selection(IConcept concept, string criteria)
• public class Description : List<Sentence>
  • public Description()
• public class Dictionary : Concept<ResourceDictionary, Resource>
  • public Dictionary(Uri uri)
  • public Dictionary(File file)
  • protected IEnumerable<Property> Properties(_Type type)
  • protected IEnumerable<Resource> Resources(_Type type)
• public class Direction : Nature<direction>
• public class Directory : OneN<DirectoryInfo, File>
  • public bool Exists { get; }
  • public IEnumerable<File> Parts { get; }
  • public Directory(DirectoryInfo dir, string extension)
  • public Directory(string root, string extension)
  • public Directory(DirectoryInfo dir, string name)
  • public Directory(DirectoryInfo dir, bool to_create)
  • public Directory(DirectoryInfo dir, string name, bool to_create)
  • public Directory(Directory dir, string name, bool to_create)
  • public Directory(Directory dir, bool to_create)
  • public Directory(SpecialFolder dir)
  • public Directory(Path path)
  • public Directory(string root, string extension)
  • public Directory(string app, string root, string extension)
  • public Directory(IEnumerable<IName> instances)
  • public Directory(string[] instances)
  • public Directory(Directory root, string extension)
  • public string Extend(string name)
  • public string Extend(Name name)
  • public Directory Remove(Directory dir)
  • public Uri Uri(string extension)
  • public Uri Uri(Name extension)
• public class Document : Concept<XDocument, IName>
  • public Document(Full_Name fullName)
  • public _Element Root { get; }
  • public IEnumerable<Element> Elements<type>()
  • public IEnumerable<Element> Elements()
  • public IEnumerable<Element> Elements(string name)
  • public Document(_Stream stream)
  • public void Combine()
  • public IEnumerable<_Element> Elements()
  • public IEnumerable<_Element> Elements(string name)
  • public IEnumerable<_Element> Elements<type>()
• public class Double : Numeric<double>
  • protected Double(double angle, object parameter)
  • protected void Parse(Element element)
• public class Element : One<XElement>, IName, IBe<string>
• public class Double_Template : Template
  • public Double_Template()
• public class Elements<type> : _Element
  • public Elements(IEnumerable<type> instances)
  • protected virtual void Elemente(IEnumerable<type> instances)
• public class Enabler : Capacity
  • public bool Be_Enablable { get; }
  • public bool Be_Enabled { get; set; }
  • public Enabler()
  • public Enabler(bool value)
  • public void Set(bool value)
• public static class Enumerable
  • public static type Asser<type>(this Many<type> sources) where type : IOne
  • public static type Asser<type>(this Enumeration<type> sources) where type : IName
  • public static type Benjamin<type>(this Many<type> sources) where type : IOne
  • public static type Benjamin<type>(this Enumeration<type> sources) where type : IName
  • public static type Dan<type>(this Many<type> sources) where type : IOne
  • public static type Dan<type>(this Enumeration<type> sources) where type : IName
  • public static IEnumerable<File> Files(this IEnumerable<IConcept> all)
  • public static type Gad<type>(this Many<type> sources) where type : IOne
  • public static Property Get(this IEnumerable<Property> targets, string first_name)
  • public static type Gad<type>(this Enumeration<type> sources) where type : IName
  • public static type Issachar<type>(this Many<type> sources) where type : IOne
  • public static type Issachar<type>(this Enumeration<type> sources) where type : IName
  • public static type Joseph<type>(this Many<type> sources) where type : IOne
  • public static type Joseph<type>(this Enumeration<type> sources) where type : IName
  • public static type Juda<type>(this Many<type> sources) where type : IOne
  • public static type Juda<type>(this Enumeration<type> sources) where type : IName
  • public static type Levi<type>(this Many<type> sources) where type : IOne
  • public static type Levi<type>(this Enumeration<type> sources) where type : IName
  • public static type Nephtali<type>(this Many<type> sources) where type : IOne
  • public static type Nephtali<type>(this Enumeration<type> sources) where type : IName
  • public static type Ruben<type>(this Many<type> sources) where type : IOne
  • public static type Ruben<type>(this Enumeration<type> sources) where type : IName
  • public static type Simon<type>(this Many<type> sources) where type : IOne
  • public static IEnumerable<concept> Where<concept>(this IEnumerable<concept> list, IOne selection, object rel) where concept : IOne
  • public static type Simon<type>(this Enumeration<type> sources) where type : IName
  • public static IEnumerable<concept> Where<concept>(this IEnumerable<concept> list, IConcept selection, object rel) where concept : IConcept
  • public static type Zabulon<type>(this Many<type> sources) where type : IOne
  • public static type Zabulon<type>(this Enumeration<type> sources) where type : IName
• public class Enumeration<name> : OneN<_Element, name> where name : IName
  • public name[] Array { get; }
  • public bool Be_Unique { get; }
  • public name Current { get; }
  • public virtual Directory Directory { get; }
  • public virtual IEnumerable<_Element> Elements { get; }
  • public virtual string Extension { get; }
  • public name Last { get; }
  • public Many<name> Manys { get; }
  • public IEnumerable<string> Names { get; }
  • public string Plural { get; }
  • protected virtual Template Prefix { get; }
  • public IEnumerable<string> Strings { get; }
  • protected virtual Template Suffix { get; }
  • protected virtual Template Template { get; }
  • public Enumeration()
  • public Enumeration(File file)
  • public Enumeration(Document doc)
  • public Enumeration(IEnumerable<_Element> elements)
  • public Enumeration(int max, name name)
  • public Enumeration(name name)
  • public Enumeration(name name1, name name2)
  • public Enumeration(name name1, name name2, name name3)
  • public Enumeration(IEnumerable<name> parts)
  • public Enumeration(int max, IEnumerable<name> parts)
  • public Enumeration(IEnumerable<object> parts)
  • public Enumeration(int max)
  • public Enumeration(_Element element)
  • public Enumeration(string filter)
  • public virtual void Add(name part)
  • public IEnumerable<IName> Concat(IEnumerable<IName> others)
  • public virtual void Execute(method method)
  • public void Execute(IActionable target)
  • public bool Exist(IConcept target)
  • public bool Have(name type)
  • public bool Have(Type type)
  • public void Insert(int pos, name part)
  • public name Instance(int i)
  • protected virtual void Parse(string filter)
  • public void Remove(name part)
  • public void Replace(string name)
  • public void Replace(IConcept owner, IRelation relation)
  • public void Replace(name instance)
  • public void Set(int pos)
  • public void Set(name part)
  • public void Switch(name part1, name part2)
• public class Error : Sentence
  • public Error(IName subject, method where, error error)
• public class Exception : Concept<Exception, IName>
  • public Exception(string comment, Exception exception)
  • public Exception(Type type, Exception exception)
  • public Exception(string source)
  • public Exception(IName source)
• public abstract class Exhaustive<alt> : Many<alt>
  • public Exhaustive(IEnumerable<alt> possibles)
  • public Exhaustive(alt value, IEnumerable<alt> possibles)
  • public Exhaustive(int max, alt value)
  • public Exhaustive(int max, _Element element)
  • protected abstract void Add()
• public enum extension
  • ico = 7
• public class Extension : Name
  • public string Mime { get; }
  • public Extension()
  • public Extension(site extension)
• public class Failure : Sentence
  • public Failure(string verb, Type type, Exception exception)
  • public Failure(string verb, _Type type, Exception exception)
• public class FDialog<dialog> : Concept<dialog, IName> where dialog : FileDialog
  • public bool Be_Ok { get; }
  • protected virtual _Stream Stream { get; }
  • public FDialog(Name name)
  • public FDialog(Name name, Enumeration<Filter> filters)
  • public _Stream Execute()
• public class File : Concept<FileInfo, _Element>
  • public Directory Directory { get; }
  • public Document Document { get; }
  • public bool Exists { get; }
  • protected virtual string Extension { get; }
  • public string Full_Name { get; }
  • protected Reader Reader { get; }
  • public Stream Stream { get; }
  • public Uri Uri { get; }
  • public nature Nature { get; }
  • public nature Next { get; }
  • public string Path { get; }
  • public string Pretty_Name { get; }
  • public _Stream Stream { get; }
  • public File(string FullName, IEnumerable<_Element> elements)
  • public File(Directory dir, Name name, extension extension)
  • public File(Element element)
  • public File(ResourceManager manager)
  • public File(string name, Extension extension)
  • public File(Directory dir, string name, Extension extension)
  • public File(string dir, string name, extension extension)
  • public File(_Element element)
  • public File(Directory dir, Name name)
  • public File(Directory dir, Name name, string extension)
  • protected void Close()
  • protected void Create(Stream stream)
  • public void Load()
  • public void Save()
  • public void Save(IEnumerable<IOne> instances)
  • public IEnumerable<_Element> Elements<type>()
  • public void Save(IEnumerable<IName> instances)
  • public virtual void Write<type>(Stream stream)
  • public Uri Uri()
  • public Uri Uri(bool in_or_out)
  • protected void Write(Name line)
  • public void Write<type>(_Stream stream)
• public class File_Element : _Element
  • public File_Element(Element Base, Directory dir)
  • public File_Element(_Element Base, Directory dir)
• public class File_Name : Chunk
• public class File_Stream : _Stream
  • public File_Stream(FileStream stream)
  • public File_Stream(FileStream stream)
• public class Files : Enumeration<File>
  • public Files(IEnumerable<Resource> resources)
  • public void Write()
• public class Filter : Name
  • public Filter(Name name)
• public abstract class Filter<concept> : Skill<Dispatcher, Boolean> where concept : IConcept
  • public Predicate<object> Predicate { get; set; }
  • public Filter(string text, Dispatcher dispatcher, Predicate<object> predicate)
  • public abstract bool Match(concept concept, object howTo)
• public class Folder : Directory
  • public Folder(string dir)
  • public Folder(string mainDir, string subDir)
  • public Folder(string app, string mainDir, string subDir)
• public class Form : _Object<Subject, Verb>
  • public Subject Subject { get; }
  • public Verb Verb { get; }
  • public Form()
  • public Form(string subject)
  • public Form(Name subject)
  • public Form(Subject subject)
  • public Form(Subject subject, Verb verb)
  • public Form(IName subject, method verb)
  • public Form(IName subject, verb verb)
  • public Form(Verb verb)
• public class From : Complement
  • public From(Type type)
  • public From(_Type type)
  • public From(string table)
• public class Full_Name : Name
  • public Full_Name(string first, string middle, string last)
  • public Full_Name(Header head, Separator sep, Prefix pre, string body, Suffix suf)
  • public Full_Name(Directory dir, string father, string son)
  • public Full_Name(_Type father, Name son)
• public class Futur : _Time
  • public Futur(string source)
  • public Futur(Name source)
• public abstract class Get<Array> : Concept<Array, Binary_Reader>
  • public array Array { get; }
  • public abstract Word<array> Part { get; }
  • public Get()
  • public Get(string reader)
  • public Get(BinaryReader reader)
  • public Get(BinaryReader reader, Integer length)
  • public Array Source { get; }
  • public Get(Name name)
  • public Get(int length)
  • public Get(BinaryReader reader)
  • public Get()
  • public bool Be(int size)
  • protected abstract Array Read()
• public class Gif : Extension
• public class Group : Concept<Group, Capture>
• public class Handler<handler> : One<handler>
• public class Handler : Concept<RoutedEventHandler, IName>
  • public Handler(RoutedEventHandler source)
• public static class Handlers
  • public sealed delegate Order : MulticastDelegate
• public class Header : String
• public abstract class Hexadecimal : Byte
• public class Html : Extension
• public interface IActionable : IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
  • void Execute(Name taskName, Element parameters)
  • Capacity Capacity(Name choice)
  • void Execute(Name taskName, _Element parameters)
• public interface IBase : IName, IBe, IRoot, IDisposable, IExtend, IClean
  • Property Property(Type name)
  • Property Property(_Type name)
• public interface IBe : IRoot, IDisposable
  • bool Be_Complete { get; }
  • void Stamp()
• public interface IBe<part>
• public interface ICapacity
• public class Ico : File
• public interface IComplement : IName, IBe<string>
• public interface IClean
  • void Clean()
• public interface IConcept : IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
  • File File { get; }
  • object Source { get; }
  • bool Be(string name)
  • bool Be(object Object)
  • void Execute()
  • void Execute(method method)
  • void Relate(IConcept owner)
  • void Relate(IName owner, int i)
  • void Relate(IRelation relation)
  • void Replace(IRelation relation)
• public interface IConcept<entity, name> : IConcept<name>, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable, IPartable<name>, IValue<entity>, IChanged where name : IName
• public class Identifier : Name
  • public Identifier(Element element)
  • public Identifier(_Element element)
• public interface IElement : IIdentifier
  • Element Element { get; }
  • _Element Element { get; }
• public interface IExecute
• public interface IFamily<one>
• public interface IExtend
  • void Prefixe(Template prefix)
  • void Suffixe(Template suffix)
• public interface IFile
  • Extension Extension { get; }
  • _Element Element { get; }
  • string Extension { get; }
• public interface IHave : ISingular<bool>, IName, IBe<string>, IType, IBe<Type>
• public interface IIdentifier
  • Identifier Identifier { get; }
• public interface IMany : IElement, IBe<XElement>
• public interface IMany<part> : IMany, IElement, IBe<XElement>, IPosition, IPlural<part>, ICapacity
• public interface IList : IName, IBe, IRoot, IDisposable
  • int Count { get; }
• public class Image : Resource<Bitmap>
  • public Image(string name, Bitmap value)
• public interface IName : IBe, IRoot, IDisposable
  • string Name { get; }
  • _Element Element { get; }
  • _Type I { get; }
  • Name Name { get; }
  • Template Template { get; }
• public class Information : Phrase
• public class Information<info, part> : One_Many<info, part> where info : FileSystemInfo where part : IOne
• public class Integer : Numeric<int>
  • protected int Result
  • public Integer(string source, CultureInfo culture)
  • public void Change(int newvalue)
  • public void Decrease(int value)
  • public void Increase(int value)
  • public void Maximise(int max)
  • protected void Minimise(int max)
• public class Invariant : Culture
  • public Invariant()
• public interface IObject : IBe<object>
• public interface IOne : IElement, IBe<XElement>, IType, IBe<Type>, IName, IBe<string>, IObject, IBe<object>
• public interface IOneN<one, part> : IValue<one>, IObject, IBe<object>, IList<part>, ICollection<part>, IEnumerable<part>, IEnumerable, IChanged, IExecute
• public interface IPair
• public interface IPlural<part>
• public interface IPosition
• public interface IObjects<entity>
  • entity Current { get; }
  • IEnumerable<entity> Instances { get; }
• public interface IOneN<part> : IList, IName, IBe, IRoot, IDisposable, IChanged
  • part First { get; }
  • part Second { get; }
  • part Third { get; }
• public interface IPartable<name> where name : IName
  • name Current { get; }
  • IEnumerable<Name> Names { get; }
  • Enumeration<name> Parts { get; }
• public interface IRelation : IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
  • Boolean Be_Opposable { get; }
  • Trilean Be_Reflexive { get; }
  • Trilean Be_Symetric { get; }
  • Trilean Be_Transitive { get; }
  • IOne Other(IOne source)
  • void Relate(IRelation target)
• public interface IRelational
  • Enumeration<IRelation> Relations()
• public interface ISemantic
• public interface ISingular<one> : IName, IBe<string>, IType, IBe<Type>
• public interface IRoot : IDisposable
  • string String { get; }
  • Type Type { get; }
  • bool Be(string compare)
  • bool Be(object compare)
• public interface ISkill : IName, IBe, IRoot, IDisposable
  • void Execute(object value, Complement[] operand)
  • void Nominale(object value, Complement[] operand)
  • void Reverse(object value, Complement[] operand)
  • void Execute(IName value, Complement[] operand)
  • void Nominale(IName value, Complement[] operand)
  • void Reverse(IName value, Complement[] operand)
• public interface IType : IBe<Type>
• public interface IValue<type>
  • value Value { get; }
  • type Default { get; }
  • type Value { get; }
  • bool Be(type value)
• public interface IWhere<part> where part : IName
  • IEnumerable<part> Where(object parameter)
• public class Jpeg : Extension
• public class Line : One<StreamReader>
• public class Local_Application : Folder
• public class Local_Data : Folder
  • public Local_Data()
  • public Local_Data(string appData, string extension)
• public class Manager<resource> : Concept<ResourceManager, Resource>
  • public Resource Instance(string name)
• public enum manner
  • Deep = 2
  • Normal = 1
  • Shallow = 0
• public class Many<chunk> : List<chunk>, IList, IName, IBe, IRoot, IDisposable, IClean, IChanged
  • public value[] Array { get; }
  • protected bool Be_Not_Found { get; }
  • public int Position
  • public virtual bool Be_Complete { get; }
  • public virtual bool Be_Empty { get; }
  • public virtual bool Be_Error { get; }
  • public int Capacity { get; }
  • public value Current { get; }
  • public virtual Directory Directory { get; }
  • public virtual Extension Extension { get; }
  • public value Fifth { get; }
  • public value First { get; }
  • public value Fourth { get; }
  • public virtual IEnumerable<value> Instances { get; }
  • public value Last { get; }
  • protected virtual IEnumerable<Element> Parts { get; }
  • public int Position { get; protected set; }
  • public value Second { get; }
  • protected virtual Element Tag { get; }
  • public value Third { get; }
  • public chunk Current { get; }
  • public virtual _Element Element { get; }
  • public chunk First { get; }
  • public chunk Fourth { get; }
  • public _Type I { get; }
  • public IEnumerable<chunk> Instances { get; }
  • public chunk[] ItemArray { get; }
  • public chunk Last { get; }
  • public Name Name { get; }
  • public string Plural { get; }
  • public chunk Second { get; }
  • public virtual string String { get; }
  • public virtual Template Template { get; }
  • public chunk Third { get; }
  • public Type Type { get; }
  • public chunk Value { get; }
  • public event Handler Event_Changed
  • public Many(object value)
  • public Many(string fullname)
  • public Many(Type type)
  • public Many(value part)
  • public Many(value part1, value part2)
  • public Many(int max, value part)
  • protected Many(Element element)
  • public Many(IEnumerable<value> parts)
  • protected Many(IEnumerable<value> parts, object parameter)
  • public Many(int max, IEnumerable<value> parts)
  • public Many(chunk name)
  • public Many(int max, chunk part)
  • public Many(IEnumerable<chunk> parts)
  • public Many(int max, IEnumerable<chunk> parts)
  • public virtual void Add(value addition)
  • protected void Browse(Method method)
  • protected void Browse(Handler handler, Arguments arguments)
  • protected void Browse(object parameter)
  • protected void Browse()
  • public virtual bool Be(string name)
  • public virtual bool Be(object other)
  • public virtual bool Be(IName name)
  • public virtual void Changed()
  • public IEnumerable<IName> Concat(IName name)
  • public Name Concat(Name name)
  • protected void Dispose(object target)
  • protected virtual void Each(object parameter)
  • protected virtual void Each()
  • protected int Get(value chunk)
  • public virtual value Get(string search)
  • protected bool Get(int i, string search)
  • protected int Get(chunk chunk)
  • public virtual chunk Get(string search)
  • protected bool Get(int i, Name search)
  • protected virtual void Initial()
  • public virtual void Insert(value addition)
  • public value Instance(int i)
  • public value Instance(string name)
  • public value Instance(Type type)
  • public void Positione(int i)
  • protected virtual void Initialise()
  • public virtual void Insert(chunk addition)
  • public chunk Instance(int i)
  • public chunk Instance(Name name)
  • public chunk Instance(IName type)
  • public chunk Instance(string type)
  • public chunk Instance(_Type type)
  • public chunk Instance()
  • protected virtual void Prepare()
  • public virtual void Remove(value part)
  • public void Replace(string name)
  • public void Replace(value instance)
  • public void Set(int pos, value addition)
  • public void Switch(value part1, value part2)
  • protected virtual void Ultimate()
  • protected void Send(method method, object parameter)
  • public void Set(int pos, chunk addition)
  • protected void Set(_Element element)
  • public void Set(chunk chunk)
  • public void Set(int pos)
  • public void Stamp()
  • protected virtual void Start()
  • public void Switch(chunk part1, chunk part2)
• public class Match : Concept<Match, Group>
• public class Me : Name
• public class Member<info> : OneN<info, IName> where info : MemberInfo
  • protected virtual info Default_Value { get; }
  • public Member(string name, object target)
  • public Member(Type type)
  • protected bool Have_Target { get; }
  • protected IName Target { get; }
  • public Member(info member, IName target)
• public class Memory_Stream : _Stream
  • public Memory_Stream(_Stream stream)
  • public Memory_Stream(File file)
• public class Method : Member<MethodInfo>
  • public bool Result { get; }
  • public Method(string method, object target)
  • public Boolean Result { get; }
  • public Method(MethodInfo method, IName target)
  • public Method(string method, IName target)
  • public Method(Name method, IName target)
  • public void Invoke(IName target)
• public class Multiplication<operand> : Transitive<operand>
  • public Multiplication(Element element)
  • public Multiplication(_Element element)
• public class My : Directory
• public class Name : Many<string>, IExtend
  • public string Alias { get; }
  • public string Branch_Name { get; }
  • public bool Have_Space { get; }
  • public IEnumerable<string> Chunks { get; }
  • public string Extension { get; }
  • public string First_Name { get; }
  • public string Last_Name { get; }
  • public string Lower { get; }
  • protected virtual string Separator { get; }
  • public string Singular { get; }
  • protected virtual string Suffix { get; }
  • public Name Lower { get; }
  • public string Middle_Name { get; }
  • public string Owner_Name { get; }
  • public Name Plural { get; }
  • public string Root { get; }
  • protected virtual Separator Separator { get; }
  • public Name Singular { get; }
  • public string Tree_Name { get; }
  • public Name(Type type)
  • public Name(string name, IEnumerable<string> names)
  • public Name(Chunk chunk)
  • protected Name(Chunk chunk1, Chunk chunk2)
  • protected Name(IEnumerable<Chunk> chunks)
  • public Name(Element element)
  • public Name(_Type type1, _Type type2)
  • public Name(_Type type)
  • public Name(string str1, string str2, string str3)
  • public Name(object name)
  • public Name(XName name)
  • public Name(IName element)
  • public Name(IEnumerable<string> names)
  • public Name(XmlNode node)
  • public static Name op_Implicit(string x)
  • public void Add(string addition)
  • public virtual bool Be(IName other)
  • public void Clean(RegEx cleaner)
  • public void Clean()
  • public void Replace(string cha, string replacement)
  • public void Set(Element element, string xmlName)
  • public void Set(_Element element, string xmlName)
  • public void Set(Chunk addition)
  • public void Set(IEnumerable<IName> additions)
  • public void Set(string addition)
  • public void Swap(Name name)
  • public void Trim()
• public class Name_Selection : Selection<string>
  • public Name_Selection(IConcept concept, string criteria)
• public static class Name2
  • public static string FatherName(this string name)
  • public static string FirstName(this string name)
• public class NameSpace : Concept<XNamespace, IName>
  • public Uri Uri { get; }
  • public NameSpace(Property prop)
  • public NameSpace(Name name)
  • public NameSpace(XName xname)
  • public NameSpace()
• public class Natural_Element : _Element
  • public Natural_Element(Element Base, Element type)
  • public Natural_Element(_Element Base, _Type type)
• public abstract class Nature<Enum> : One<Enum>
• public class Not : Name
  • public Not(Name source, string initial)
  • public Not(Prefix not, string name)
• public abstract class Numberer : String
• public abstract class Numeric<entity> : Relative<entity>
  • public Numeric(entity source, CultureInfo culture)
  • public Numeric(_Element element)
  • protected Numeric(string name)
  • protected Numeric(Element element)
  • protected Numeric(entity angle, object parameter)
  • public abstract bool Be(entity origin)
  • protected virtual void Parse(Element element)
  • protected virtual void Parse(_Element element)
• public class One_Many<value, part> : One<Tuple<One<value>, Plural<part>>> where part : IOne
• public class One<value> : _<value>, IOne, IElement, IBe<XElement>, IType, IBe<Type>, IName, IBe<string>, IObject, IBe<object>
• public class OneN<one, n> : Tuple<one, Many<n>>, IOneN<n>, IList, IName, IBe, IRoot, IDisposable, IChanged
  • protected bool Be_Concept { get; }
  • public bool Be_Empty { get; }
  • public virtual bool Be_Error { get; }
  • protected bool Be_Fozzy { get; }
  • public int Count { get; }
  • protected n Current { get; }
  • public virtual Directory Directory { get; }
  • public virtual _Element Element { get; }
  • public virtual string Extension { get; }
  • public virtual File File { get; }
  • public n First { get; }
  • public virtual Name Full_Name { get; }
  • public bool Have_Instances { get; }
  • protected bool Have_Value { get; }
  • public _Type I { get; }
  • public virtual IEnumerable<n> Instances { get; }
  • public virtual Name Name { get; }
  • protected Many<n> ns { get; }
  • public Many<n> Ns { get; }
  • protected Type Part_Type { get; }
  • public IEnumerable<n> Parts { get; }
  • protected int Position { get; }
  • public n Second { get; }
  • public virtual string String { get; }
  • public object Target { get; }
  • public virtual Template Template { get; }
  • public n Third { get; }
  • public virtual bool To_Create { get; }
  • public virtual Type Type { get; }
  • public one Value { get; }
  • public event Handler Event_Changed
  • public OneN()
  • public OneN(one name)
  • public OneN(one name, int max)
  • public OneN(int max)
  • public OneN(one name, n part1)
  • public OneN(one name, n part1, n part2)
  • public OneN(one name, n part1, n part2, n part3)
  • public OneN(n part)
  • public OneN(IEnumerable<n> parts)
  • public OneN(Many<n> parts)
  • public OneN(one name, IEnumerable<n> parts)
  • public void Add(n part)
  • public virtual void Add(IEnumerable<n> objects)
  • protected virtual void Add(_Element element)
  • public virtual bool Be(string compare)
  • public virtual bool Be(object other)
  • public virtual void Clean()
  • public void Dispose()
  • public virtual void Execute()
  • public n Get(_Element element)
  • public n Get(string name)
  • public virtual instance Get<instance>(string name) where instance : IName
  • protected void Insert(int pos, n part)
  • public n Instance(string name)
  • protected virtual void Live()
  • protected virtual string Namer(n instance)
  • protected virtual void Prepare()
  • public virtual void Re_Set()
  • protected void Remove(int pos)
  • protected virtual void Set(int pos)
  • public void Stamp()
  • protected virtual void Terminate()
• public class Open_File : Enumeration<Filter>
  • public bool Be_Complete { get; }
  • public Type Type { get; }
  • public Open_File(Element element)
  • public Open_File(_Element element)
• public class Or : CBoolean
  • public Or(string name, verb verb, IConcept concept)
  • public Or(Subject subject)
• public class Pair<entity> : Enumeration<entity> where entity : IName
  • public bool Be_Complete { get; }
  • public virtual bool Be_FallBack { get; }
  • public virtual bool Be_Partial { get; }
  • public bool Have_Left { get; }
  • public bool Have_Right { get; }
  • public entity Left { get; }
  • public entity Right { get; }
  • public Pair(entity a)
  • public Pair(string filter)
• public class Pair<type1, type2> : One<Tuple<type1, type2>>, IPair
• public class Past : _Time
  • public Past(string source)
  • public Past(Name source)
• public class Path : Chunk
• public class Pattern<name> : OneN<Template, name> where name : IName
  • protected Chunk Body { get; }
  • protected Chunk Prefix { get; }
  • protected Chunk Suffix { get; }
  • public Template Template { get; }
  • public Pattern(string target)
  • protected string Body { get; }
  • protected string Prefix { get; }
  • protected string Suffix { get; }
  • public Pattern(Template template, name target)
  • public Pattern(Template template, string target)
  • public Pattern(Many<name> targets)
  • public Pattern(Template template, Plural<name> parts)
  • public Pattern(name target, Template template)
  • public Pattern(name target, Separator sep)
  • public Pattern(IEnumerable<name> targets)
  • public Pattern(Template template, IEnumerable<name> parts)
  • protected void Concat(Chunk ajout)
  • protected void Concat(Chunk first, IName second)
• public class PerCent : Double
• public class Person_Name : Name
• public class Phrase : One_Many<Structure, Complement>
• public class Plural<value> : Many<value> where value : IOne
• public class Pluraler : OneN<Name, _Type>
  • public Pluraler(string name)
  • public Pluraler(Type type)
  • public string Plural { get; }
  • public string Singular { get; }
  • public Pluraler(Name name)
  • public Pluraler(_Type type)
• public class Prefix : String
• public class Property : Member<PropertyInfo>
  • public bool Be_Enumeration { get; }
  • public bool Be_Our { get; }
  • public bool Be_State { get; }
  • public bool Have_Value { get; }
  • public XAttribute XAttribute { get; }
  • public Property(string name, object target)
  • public Property(object target, Name name)
  • public bool Be_Of(Type type)
  • public bool Be_Of(_Type type)
  • public bool Implements(_Type type)
  • public void Load(object target, object[] parameters)
  • public void Set(object target, object value)
  • public object Target_Value(object target)
• public class Propertys : Reflection<Property, PropertyInfo>
• public class Range<entity> : Many<entity>
  • protected Range(string name)
  • protected Range(Element element)
  • protected Range(IEnumerable<entity> entities, object parameter)
  • public Range(entity value)
  • public Range(_Element element)
  • public Range(entity min, entity value, entity max)
  • protected void Set(entity value)
• public class Reader : Skill<StreamReader, File>
  • public Stream Stream { get; }
  • public XDocument XDocument { get; }
  • public string Content { get; }
  • public Document Document { get; }
  • public Reader(StreamReader reader)
  • public IEnumerable<Element> Elements()
  • public IEnumerable<Element> Elements<type>()
  • public Name Line()
• public abstract class Reflection<our, info> : One_Many<Type, our> where our : IOne
• public class RegEx : One_Many<Regex, Match>
• public class Relations<type> : Plural<type> where type : IRelation
• public class Relation : Relation<IConcept>
  • public Relation()
• public abstract class Relation<concept> : Concept<concept, IName>, IRelation, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable where concept : IConcept
  • public abstract Boolean Be_Opposable { get; }
  • public abstract Trilean Be_Reflexive { get; }
  • public abstract Trilean Be_Symetric { get; }
  • public abstract Trilean Be_Transitive { get; }
  • protected virtual cardinality Cardinality { get; }
  • public Name Nature { get; }
  • public concept Source { get; }
  • public Relation()
  • public Relation(concept target)
  • public Relation(string name, concept target)
  • public Relation(string name)
  • public Relation(object relation, concept target)
  • public Relation(concept target, IName complement)
  • public Relation(string name, concept target, IName complement)
• public class Relative : Uri
  • public Relative(Uri uri)
  • public Relative(Uri uri)
• public abstract class Relative<entity> : Concept<entity, Range<entity>>, IRelative<entity>
  • public entity Maximum { get; }
  • public entity Minimum { get; }
  • public entity Origin { get; }
  • protected Range<entity> Range { get; }
  • public Relative(entity source, CultureInfo culture)
  • public Relative(entity min, entity max)
  • protected Relative(string name)
  • public Relative(IEnumerable<entity> entities)
  • protected Relative(Element element)
  • protected Relative(entity source, object parameter)
  • public Relative(_Element element)
  • public Relative(entity min, entity value, entity max)
• public class Report : Phrase
• public class Resource : Concept<Memory_Stream, File>
  • public Stream Stream { get; }
  • protected virtual string Extension { get; }
  • public _Stream Stream { get; }
  • public string Value { get; }
  • public Resource(string name, UnmanagedMemoryStream stream)
• public class Resource<value> : Concept<value, IName>
  • public Resource(Name name, value value)
• public class RichText : Extension
• public class Root_Element : Element
• public class Root : _Element
  • public Root(XElement source)
  • public Root(XDocument source)
• public class Rtf : File
  • public Rtf()
  • public Rtf(string FullName)
  • public Rtf(_Element element)
  • public void Load(TextRange range)
  • public void Write(TextRange range)
  • public void Write(string text)
• public class Selecter : Capacity
  • public bool Be_Selectable { get; }
  • public bool Be_Selected { get; set; }
  • public Selecter()
  • public Selecter(bool value)
  • public void Set(bool value)
• public abstract class Selection<criteria> : Skill<Boolean>
  • public Selection(IConcept value, criteria criteria)
  • protected abstract void Test(criteria criteria)
• public class Sentence : OneN<Form, Complement>
  • public List<Complement> Complements { get; }
  • public object Response { get; }
  • public Subject Subject { get; }
  • public Verb Verb { get; }
  • public Sentence()
  • public Sentence(string subject)
  • public Sentence(IName subject, method where, string complement)
  • public Sentence(IName subject, verb where)
  • public Sentence(Verb verb, IEnumerable<Complement> complements)
  • public Sentence(Verb verb)
  • public Sentence(Subject subject)
• public class Separator : Name
  • public string Concatenater { get; }
  • public Separator(Chunk sep)
  • public string Format(string first, object second)
• public class Setting : One<SettingsProperty>
• public class Settings<settings> : Concept<settings, Setting> where settings : ApplicationSettingsBase
• public class Serializer : Skill<XmlSerializer, _Stream>
  • public Serializer(_Type type, _Stream stream)
  • public void Do(Name name, object target)
• public class Settings : Concept<ApplicationSettingsBase, IName>
  • public Settings(ApplicationSettingsBase settings)
• public class Singuler : Numberer
• public enum site
• public class Skill<target> : Skill<IConcept, target> where target : IName
  • public Skill(IConcept value)
• public class Skill<value, target> : Concept<value, target>, ISkill, IName, IBe, IRoot, IDisposable where target : IName
  • protected destination Destination { get; }
  • protected Complement Cod { get; }
  • protected value Source { get; }
  • public Skill(source target)
  • public Skill(string name)
  • public Skill(File file)
  • public void Do(IOne value)
  • protected void Execute(object target, method method)
  • protected void Execute(object target, method method, object parameter)
  • protected void Execute(object target, string method, object parameter)
  • public void Execute(object target, Complement[] complements)
  • public void Nominale(object value, Complement[] operand)
  • public void Nominale(object value)
  • public void Reverse(object value, Complement[] operand)
  • public void Reverse(object value)
  • public Skill(value value)
  • public Skill(_Element element)
  • public Skill(Name name, value value)
  • public Skill(string name, value value)
  • public Skill(target element)
  • public Skill(value value, target element)
  • public Skill(value value, IEnumerable<target> targets)
  • public Skill(Name name, Directory dir, value value)
  • public void Do(IConcept value)
  • protected void Execute(IName target, method method, object parameter)
  • protected void Execute(IName target, string method, object parameter)
  • public void Execute(IName target, Complement[] complements)
  • public void Nominale(IName value, Complement[] operand)
  • public void Nominale(IConcept value)
  • public void Reverse(IName value, Complement[] operand)
  • public void Reverse(IConcept value)
  • protected void Set(target target)
• public class Space_Complement : Complement
• public class Source : Concept<object, IName>
  • public Source(object target, Name name)
• public class States : Enumeration<State>
  • public States(Type type)
  • public bool Have(state state, bool value)
• public static class Statics
  • public static string Concept
  • public static string Default
  • public static string Directory
  • public static char[] Dirty
  • public static string Extension
  • public static string File
  • public static string Father_Name
  • public static string Full_Name
  • public static string Header
  • public static string Identifier
  • public static string Instance
  • public static string irregular_plural
  • public static string irregular_singular
  • public static string name
  • public static string Nature
  • public static string Natural_Name
  • public static object[] Objects
  • public static string Position0123
  • public static string Position01234
  • public static string Position4
  • public static string Prefix
  • public static string Pretty_Name
  • public static string Separator
  • public static string Suffix
  • public static Type[] Types
  • public static string Value
  • public static string value
• public class Stream : One<Stream>
• public class String : Tuple<string>
• public class String<attribute> : Attribute<attribute> where attribute : Attribute
  • public String(_Type target)
• public class Structure : Pair<Subject, Verb>
• public enum style
• public class Sub_Plural : Directory
• public class Subject : Name
  • public Subject(Type type)
  • public Subject(IActionable name)
• public class Suffix : String
• public class Target<source, destination> : One_Many<destination, IOne> where source : IOne
• public class Task : Concept<Boolean, IName>
  • public Task(Element element)
  • public Task(_Element element)
  • protected virtual void Execute(IActionable target, _Element parameters)
• public class Temp : Local_Data
  • public Temp()
  • public Temp(string ApplicationFolder, string AppData)
• public class Template : Name
  • public Chunk Body { get; }
  • public Chunk Prefix { get; }
  • public Chunk Separator { get; }
  • public Chunk Suffix { get; }
  • public string Body { get; }
  • public string Prefix { get; }
  • public string Separator { get; }
  • public string Suffix { get; }
  • public Template()
  • public Template(Chunk chunk)
  • public Template(Separator sep)
  • public Template(Separator sep, string template)
  • public Template(Template prefix)
  • public Template(Template prefix, Template suffix)
  • public Template(Template prefix, Body pos, Template suffix)
  • public Template(Template prefix, Body pos, Template suffix, Separator sep)
  • public Template(string prefix, string pos, string suffix, string sep)
• public class Time_Complement : Name
• public class Transitive<cod> : Skill<cod, IConcept>
  • protected Complement Cod { get; }
  • public Transitive(Element element)
  • public Transitive(_Element element)
• public class Txt : Extension
• public class Type : One<Type>, ISingular<Type>, IName, IBe<string>, IType, IBe<Type>, IFamily<Type>
• public class Type_Element : Element
• public class Uri : Concept<Uri, IName>
  • public UriKind Default { get; }
  • public string Trim { get; }
  • public Uri(Name source)
  • public Uri(File file)
  • public Uri(Path path)
  • public Uri(Uri left, Uri right)
  • public Uri(Uri uri)
  • public void Extract(_Stream source, string directory)
• public class Value_Element : Element
• public class Verb : Concept<Action, Mode>
  • protected virtual Prefix Not { get; }
  • protected virtual string Not { get; }
  • public Time_Complement Present { get; }
  • public _Time Present { get; }
• public class Warning : Sentence
  • public Warning(string subject, method where, warning warning)
  • public Warning(IName subject, method where, warning warning)
• public class Word<Struct> : One<Struct>
• public class Write : File_Stream
  • public void Copy(_Stream target)
• public class Writer : Container<StreamWriter>
• public class XAttribute : Attribute
  • public bool Be { get; }
  • public string Name { get; }
  • public string Value { get; }
  • public XAttribute()
  • public XAttribute(string attribute)
  • public XAttribute(nature attribute)
  • public XAttribute(XAttribute attribute)
  • public XAttribute(object value)
• public class XFile : File
  • public XFile(string fullname, IEnumerable<IName> concepts)
  • public XFile(string fullname, IEnumerable<_Element> concepts)
  • protected void Convert()
• public class Xml : Extension
• public class Yes_No : Name
  • public Yes_No(string yes, string no)

Fozzy.Core

• public class _Brush<brush> : Concept<brush, _Color> where brush : Brush
  • public brush Brush { get; }
  • public _Color Color { get; }
  • public Solid Intense_Brush { get; }
  • public _Brush()
  • public _Brush(brush brush, _Color color)
  • public _Brush(_Color color)
  • public _Brush(Color color)
  • public _Brush(brush brush)
• public class _Color : Concept<Color, IName>
  • public byte A { get; }
  • public byte B { get; }
  • public Solid Brush { get; }
  • public byte G { get; }
  • public Solid Intense_Brush { get; }
  • public byte R { get; }
  • public _Color()
  • public _Color(Color color)
  • public _Color(byte a, byte r, byte g, byte b)
  • public _Color(_Element element)
• public class _Relation : Concept<IConcept, IName>
  • public _Relation()
• public class _Skill : Skill<object, IConcept>
  • public object Result { get; }
  • public _Skill(string name)
  • public _Skill(IConcept part)
• public class _Sons<entity> : Objects<entity> where entity : IConcept
  • protected IEnumerable<Type> Sons { get; }
  • public _Sons()
• public enum adverb
  • From = 2
  • Into = 1
  • None = 0
• public class Blob : File_Stream
  • public Blob(Stream stream)
  • public virtual byte[] Read(byte[] blobInfo)
• public class Builder : Concept<StringBuilder, IName>
  • public Builder(Name name)
  • public Builder(_Element element)
  • public Builder(XElement source)
  • public void Add(_Element addition, bool with_LF)
  • public void Add(string addition, bool with_LF)
• public class Changed<entity> : EventArgs
  • public entity Entity { get; }
  • public Changed(entity New)
• public class Close : Ternary
  • public Close(ResourceDictionary resources)
• public class Comma : Separator
  • public Comma()
• public class Couple<entity> : Pair<entity>, ICouple<entity>, IPair<entity> where entity : IConcept
  • public Couple(entity first, entity second)
  • public Couple(IEnumerable<entity> roots)
  • public entity Other(entity target)
• public class Couple<entity1, entity2, root> : Couple<root> where entity1 : root where entity2 : root where root : IConcept
  • public entity1 First { get; }
  • public entity2 Second { get; }
  • public Couple(entity1 first)
  • public Couple(entity2 second)
  • public Couple(entity1 first, entity2 second)
  • public Couple(IEnumerable<root> roots)
  • public root Other(root person)
• public class Data : Directory
  • public Data(Name dir, string name)
  • public Data(string App, string AppData)
  • public Data(string dir)
  • public Data(Name name)
  • public Data()
• public class Debugger : String<DebuggerDisplayAttribute>
  • public Debugger(_Type type)
• public class Depth : Integer
  • public Depth()
  • public Depth(int number)
• public class Description : _Element
  • public Description(string name)
  • public Description(Name name)
  • public Description(_Element element)
• public abstract class Dis : Boolean
  • public Dis()
• public class Dispatcher : Concept<DispatcherTimer, Boolean>
  • public Boolean Be_Operating { get; }
  • public Dispatcher()
  • public Dispatcher(EventHandler gate)
  • public Dispatcher(EventHandler gate, TimeSpan interval)
  • public Dispatcher(EventHandler gate, int milliseconds)
  • public void Set(EventHandler gate)
  • public void Start()
  • public void Stop()
• public class Disposer : Dis
  • public Disposer()
  • public void Dispose()
• public class Doer<_Do, _Undo> : Concept<_Do, _Undo> where _Do : Ternary where _Undo : Ternary
  • public Ternary _Doer { get; }
  • public Ternary _Undoer { get; }
  • protected bool Be_Doing { get; }
  • protected bool Be_Done { get; }
  • protected bool Be_Undoing { get; }
  • protected bool Be_Undone { get; }
  • public Doer()
  • public Doer(_Do doer, _Undo undoer)
  • public void Complete()
  • public void Do()
  • public void Done()
  • public void Pause()
  • public void Resume()
  • public void Undo()
  • public void Undone()
• public class Doing : Story
  • public Doing(ResourceDictionary resources)
• public class Done : Story
  • public Done(ResourceDictionary resources)
• public class Double : Double
  • public Double()
  • public Double(double value)
  • public Double(double min, double value, double max)
• public class Ellapse : Concept<DateTime, MilliSeconds>
  • public bool Be_UpToDate { get; }
  • public TimeSpan Interval { get; }
  • public Ellapse()
  • public Ellapse(int refresh)
  • public Ellapse(bool min)
  • public Ellapse(TimeSpan span)
• public class Empty : Template
  • public Empty()
• public class Entity_Args : Arguments
  • public Entity_Args(object entity)
• public class Enumer<enumer> : Concept<enumer, IName>
  • public Enumer(enumer enu, Type source)
  • public Enumer(enumer enu)
  • public static enumer Enum(string name)
• public class File_Information : Name
  • public File_Information(Name dir, string name, extension extension)
  • public File_Information(DirectoryInfo dir, string name, extension extension)
  • public File_Information(string dir, string name, string extension)
• public class Float : Numeric<float>
  • public float Square { get; }
  • public Float(float value)
  • public Float(float min, float value, float max)
  • public Float(_Element element)
  • public static Float op_Implicit(float value)
• public abstract class Functionals<One, collection, Many, Final> : Multiple<One, collection, Many> where collection : IEnumerable where Many : IName
  • public IEnumerable<Final> Instances { get; }
  • public Functionals(One source)
• public class Header : Concept<Binary_Reader, IName>
  • protected Binary_Reader Reader { get; }
  • public Header(Binary_Reader reader)
  • public Header(BinaryReader reader)
• public class Heart<target> : Concept<target, Dispatcher> where target : IRegular
  • public Dispatcher Dispatcher { get; }
  • public Heart()
  • public Heart(_Element element)
  • public void Pause()
  • public void Resume()
• public interface IArray : ITuples
  • Depth Depth { get; set; }
• public interface IBe
  • bool Be_Error { get; }
• public interface IBe<entity> : IBe
  • bool Be(entity other)
• public interface ICouple<type> : IPair<type> where type : IConcept
  • type Other(type target)
• public class Identity<entity> : Concept<entity, IName>
  • public Identity(_Element element)
• public interface IDeployable : IRythmable, IActionable, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
• public interface IDispose : IDisposable
• public interface IElement
  • _Element Element { get; }
• public interface IFinish
  • void Finish()
• public interface IHave<entity>
  • bool Have(entity entity)
• public interface IInstance : IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
• public class Instances : Pattern<Name>
  • public Instances(Name source)
  • public Instances(Name source, Separator sep)
  • protected string Between(int pos)
  • protected void Concat(int min, int max, bool withSep)
  • protected virtual void Concat_First()
  • protected virtual void Concat_InBetween()
  • protected virtual void Concat_Last()
• public class Integer<attribute> : Attribute<attribute> where attribute : Attribute
  • public Integer Value { get; }
  • public Integer(Type target)
• public interface INumeric
• public interface IPair<type>
  • type Left { get; }
  • type Right { get; }
• public interface IPlural<type> where type : IConcept
• public interface IProcess : IName, IBe, IRoot, IDispose, IDisposable, IBe, ISerialize
• public interface IRegular
  • void Update(object sender, EventArgs args)
• public interface IReversable : IActionable, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
• public interface IRythmable : IActionable, IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
• public interface ISelectable
  • bool Be_Selected { get; set; }
  • void Select()
  • void Un_Select()
• public interface ISerialize
  • void Serialize(DirectoryInfo directory, File file)
• public interface ISet
  • void Set()
• public interface ISkill
  • void Execute(IConcept target)
• public interface ISynchronisable : IConcept, IBase, IName, IBe, IRoot, IExtend, IClean, IFile, IDisposable
  • void Set_Visibility()
• public interface ITuple<entity> : IName, IBe, IRoot, IDisposable
  • event Handler Changed_Event
  • bool Adjective(string name)
  • void Execute(string name)
• public interface ITuples
  • void Browse(method method)
• public class Level : Integer
  • public Level(int source)
• public class Long : Dispatcher
  • public Long(EventHandler gate)
• public class Memory_Stream : _Stream
  • public Document Document { get; }
  • public Memory_Stream(OpenReadCompletedEventArgs e)
  • public Memory_Stream(File file)
  • public Memory_Stream(_Stream stream)
• public class MilliSeconds : Integer
  • public bool To_Refresh { get; }
  • public MilliSeconds()
  • public MilliSeconds(int refresh)
  • public MilliSeconds(TimeSpan span)
• public static class Module_Properties
  • public static Property Get(this IEnumerable<Property> targets, string first_name)
• public class Multiple<One> : Multiple<One, One> where One : IConcept
  • public Multiple(Document document)
  • public Multiple(IEnumerable<_Element> sources)
  • public Multiple(IEnumerable<One> sources)
  • public Multiple(One one)
• public class Multiple<One, Many> : Objects<One, Many>, IObjects<Many> where Many : IConcept
  • protected Many First_Instance { get; }
  • protected Many Second_Instance { get; }
  • protected IEnumerable<Many> Sons { get; }
  • protected Many Third_Instance { get; }
  • public Multiple()
  • public Multiple(One source)
  • public Multiple(Systems<Many> manys)
  • public Multiple(IEnumerable<Many> manys)
  • public Multiple(One source, IEnumerable<Many> manys)
  • public Multiple(One source, int position)
  • public Multiple(_Element element)
  • public Multiple(Name name)
  • public Multiple(Name name, One source)
  • public Multiple(Document doc)
  • public Multiple(IEnumerable<_Element> sources)
  • protected virtual void Change(int before, int after)
  • protected virtual void Each(Many many)
  • protected virtual void Event()
  • protected virtual void Inform(bool HasChanged)
  • public Many Instance(Name name)
  • public virtual void Propertise()
  • protected void Select(IConcept search)
  • protected void Select(int pos)
  • public virtual void Set(One one)
  • protected void Set(int pos)
  • protected virtual void Shift()
  • protected virtual void Synchronize(Many entity)
• public abstract class Multiple<One, collection, Many> : Concept<One, Many> where collection : IEnumerable where Many : IName
  • public bool Be_Selected { get; }
  • public bool Be_Unique { get; }
  • protected abstract collection Collection { get; }
  • public int Count { get; }
  • public Many Current { get; }
  • public IEnumerable<Many> Instances { get; }
  • protected IEnumerable<Many> Manys { get; }
  • protected int Position { get; }
  • protected Type Type_Many { get; }
  • public Multiple()
  • public Multiple(One source)
  • public Multiple(_Element element)
  • public Multiple(Name name)
  • public Multiple(IConcept part)
  • public Multiple(IEnumerable<IConcept> parts)
  • protected virtual void Add(IEnumerable<Many> nodes)
  • protected virtual void Add(Many node)
  • protected bool Change(int i)
  • public Many Instance(int pos)
  • public IEnumerable<Many> Nexts(IEnumerable<IConcept> firsts)
• public abstract class Multiples<One, Many> : Concept<Objects<One>, Objects<Many>> where One : IConcept where Many : IConcept
  • public IEnumerable<Many> Instances { get; }
  • protected abstract IEnumerable<Many> Sources { get; }
  • public Multiples(IEnumerable<One> nodes)
• public abstract class Nexts<father, son> : Multiple<father, son> where father : IConcept where son : IConcept
  • protected abstract property Next { get; }
  • public Nexts(father source)
• public class Node
  • public bool Be_Deployed { get; set; }
  • public bool Be_Selected { get; }
  • public Node()
  • public void Deploy()
  • public virtual void DeSelect()
  • public virtual void Select()
• public class Objects<entity> : Systems<entity>, IObjects<entity> where entity : IConcept
  • public string Current_Name { get; }
  • public Directory Directory { get; }
  • public string Version { get; }
  • public Objects()
  • public Objects(IEnumerable<entity> entities)
  • public Objects(entity[] entities)
  • public Objects(entity entity)
  • public Objects(int capacity)
  • public static Objects<entity> op_BitwiseAnd(Objects<entity> firsts, Objects<entity> seconds)
  • protected void Dirtise(entity entity)
  • protected IEnumerable<type> Enumeration<type>()
  • public IEnumerable<entity> Instance(entity target)
  • public void Select(IConcept search)
  • protected IEnumerable<entity> Where(IConcept target, string prop)
• public abstract class Objects<One, Many> : Systems<One, Many> where Many : IConcept
  • public Objects<Many> _Objects { get; }
  • protected IEnumerable<Many> Concepts { get; }
  • public int Count { get; }
  • public Many Current { get; }
  • public IEnumerable<Many> Manys { get; }
  • public Objects()
  • public Objects(One source)
  • public Objects(IEnumerable<Many> manys)
  • public Objects(One source, IEnumerable<Many> manys)
  • public Objects(One source, int position)
  • public Objects(_Element element)
  • public Objects(Name name)
  • public Objects(Name name, One source)
  • public Objects(IConcept part)
  • public Objects(Document doc)
  • public Objects(IEnumerable<_Element> sources)
  • public IEnumerable<Many> Except(Many target)
  • public Many Instance(int pos)
  • public IEnumerable<Many> Nexts(IEnumerable<IConcept> firsts)
• public class One_N<One, Many, Root> : Multiple<One, Many>, IPlural<Root> where One : IConcept where Many : Root, IRelation where Root : IConcept
  • public One_N(One one, IEnumerable<Many> instances)
  • public bool Be_Many(Root root)
  • public bool Be_One(Root root)
• public class Open : Ternary
  • public Open(ResourceDictionary resources)
• public class Opener : Doer<Open, Close>
  • public bool Be_Closed { get; }
  • public bool Be_Closing { get; }
  • public bool Be_Opened { get; }
  • public bool Be_Opening { get; }
  • public Opener(ResourceDictionary resources)
• public class PerCent : Double
  • public PerCent(XElement element)
  • public PerCent(string source)
• public enum position
  • bottom = 1
  • center = 2
  • hide = 0
  • top = 3
• public class Position0 : Name
  • public Position0()
  • public Position0(string pos)
• public class Position1 : Name
  • public Position1()
• public class Pretty_Pattern : Pattern<Name>
  • public Pretty_Pattern(Name source)
• public class Protocole
  • public Protocole()
• public class Random : Concept<Random, Integer>
  • public float Float { get; }
  • public int Integer { get; }
  • public Integer Max { get; }
  • public Integer Min { get; }
  • public Random()
  • public Random(int max)
  • public Random(int min, int max)
• public class Read : File_Stream
  • public Read(Name name)
• public class Relations<one, many> : Objects<one, many> where one : IConcept where many : IRelation
  • public Relations(one target, IEnumerable<many> manys)
• public class Rythm<One, Many> : Concept<Multiple<One, Many>, Timer> where Many : IConcept
  • public bool Be_UpToDate { get; }
  • public Timer Timer { get; }
  • public Rythm()
  • public void Set(EventHandler handler)
• public class Semi_Column : Separator
  • public Semi_Column()
• public class Serialization_Exception : Exception
  • public Serialization_Exception(Exception ex)
• public class Solid : _Brush<SolidColorBrush>
  • public Solid()
  • public Solid(_Color color)
  • public Solid(Color color)
  • public Solid(SolidColorBrush brush)
• public abstract class Source<source, column, reference> : Concept<source, Concept<reference, IName>>
  • protected abstract IEnumerable<column> Columns { get; }
  • protected IEnumerable<Source> Precursors { get; }
  • protected reference Target { get; }
  • public Source(source source)
  • protected abstract Source Property(column col)
• public class Story : Concept<Storyboard, Boolean>
  • public bool Be_Completed { get; }
  • public bool Be_Started { get; }
  • public event EventHandler Started
  • public Story()
  • public Story(ResourceDictionary resources, string root)
  • public void Begin()
  • public void Completed()
  • public void Pause()
  • public void Resume()
  • public void Stop()
• public class Stream_Task : _Skill
  • protected Integer Length { get; }
  • public _Stream Stream { get; }
  • public Stream_Task(direction dir, Stream target)
  • public virtual string Execute(Stream stream)
• public class Systems<entity> : Enumeration<entity> where entity : IName
  • protected sealed delegate Actioner<entity> : MulticastDelegate where entity : IName
  • protected sealed delegate Actioner_with_Parameter<entity> : MulticastDelegate where entity : IName
  • public entity[] Array { get; }
  • public IEnumerable<entity> Ascendings { get; }
  • public bool Be_Empty { get; }
  • public bool Be_Multiple { get; }
  • public bool Be_Unique { get; }
  • public entity Default { get; }
  • public IEnumerable<entity> Descendings { get; }
  • public entity Random { get; }
  • public Systems()
  • public Systems(IEnumerable<entity> entities)
  • public Systems(entity[] entities)
  • public Systems(entity entity)
  • public Systems(int capacity)
  • public void Add(IEnumerable<entity> items)
  • public bool Be_Present(entity search)
  • protected void Browse(object parameter)
  • protected void Browse()
  • protected virtual void Change(int search)
  • protected virtual void Each(entity entity, object parameter)
  • protected virtual void Each(entity entity)
  • protected virtual void Initial()
  • protected void Replace(entity entity)
  • public virtual void Select(entity search)
  • public void Set(object value)
  • protected virtual void Ultimate()
• public abstract class Systems<One, Many> : Concept<One, Many> where Many : IName
  • public bool Be_Selected { get; }
  • public bool Be_Unique { get; }
  • protected Many Default { get; }
  • public virtual Name Name { get; }
  • public Timer Time_Stamp { get; }
  • protected virtual Type Type_Many { get; }
  • public Systems()
  • public Systems(One source)
  • public Systems(One source, IEnumerable<Many> manys)
  • public Systems(IEnumerable<Many> manys)
  • public Systems(One source, int position)
  • public Systems(_Element element)
  • public Systems(Name name)
  • public Systems(Name name, One source)
  • public Systems(IConcept part)
  • public Systems(IEnumerable<_Element> sources)
  • protected bool Changed(int i)
  • public IEnumerable<Many> Nexts(IEnumerable<IConcept> firsts)
• public class Ternary : Pair<Story>
  • public bool Be_Doing { get; }
  • public bool Be_Done { get; }
  • public Story Doing { get; }
  • public Story Done { get; }
  • public Ternary(ResourceDictionary resources)
  • public virtual void Begin()
  • public void Complete()
  • public virtual void Completed()
  • public void Pause()
  • public void Resume()
  • public virtual void Stop()
• public class Timer : Dispatcher
  • public bool Be_UpToDate { get; }
  • public Timer()
  • public Timer(EventHandler handler)
  • public void Pause()
  • public void Resume()
  • public void Start()
  • public void Stop()
• public class Triple_Template : Template
  • public Triple_Template()
  • public Triple_Template(Separator sep)
• public class Uple<entity>
  • public virtual bool Be_Enabled { get; }
  • public Uple()
• public class Uple<e1, e2, e3> : Concept<e1, Multiple<e2, e3>> where e3 : IConcept
  • protected Multiple<e2, e3> Group { get; }
  • public Uple()
  • public Uple(e1 entity1)
  • public Uple(e1 entity1, e2 entity2)
  • public Uple(_Element element)
• public class Url : Name
  • public Uri Uri { get; }
  • public Url(_Element element)
  • public Url(string address)
• public class Void<source> : Skill<source, IConcept> where source : IConcept
  • protected source Source { get; }
  • public Void(source source, IConcept target)

Fozzy.Kernel

• public class _Algorithm<info, process> : _Object<info, process>
  • public process Algorithm { get; }
  • public info Information { get; }
  • public _Algorithm(info info)
• public static class _IO
• public class _Message : Concept<string, IName>, IMessage
  • public _Message(string FullName)
  • public void Error(string error)
  • public void Show(string message)
• public class _Method : _Skill
  • public _Method(string name)
• public static class _Semantic
• public class Argument<entity> : Concept<entity, IName> where entity : EventArgs
  • public Argument(string name)
• public static class Auxiliary
• public enum axis
  • X = 0
  • Y = 1
  • Z = 2
• public class Change<item> : Concept<item, IName>
  • public Change(item to)
• public class Command : Concept<OleDbCommand, Sentence>, ICommand
  • public OleDbCommand Ole { get; }
  • public event EventHandler CanExecuteChanged
  • public Command(Action<object> execute)
  • public Command(Action<object> execute, Predicate<object> canExecute)
  • public Command(Sentence sentence)
  • public bool CanExecute(object parameter)
  • public void Execute(object parameter)
• public class Creations<entity> : Objects<entity> where entity : IConcept
  • public Creations(int number)
• public class Cube<entity> : Concept<Array, IName> where entity : IConcept
  • protected IEnumerable<entity> Instances { get; }
  • public Cube()
  • public entity Get(string position)
  • public entity Get(int x, int y, int z)
• public class Dictionary<entity> : Dictionary<string, Action<entity>>
  • public Dictionary()
  • public virtual void Set()
• public class Equation : Template
  • public Equation()
  • public Equation(Template suffix)
• public class Equation_Prefix : Template
  • public Equation_Prefix()
• public class Equation_Prefix2 : Template
  • public Equation_Prefix2(string addition)
• public class Equation_Suffix : Template
  • public Equation_Suffix()
• public class Equation_Suffix2 : Template
  • public Equation_Suffix2(string addition)
• public enum family
  • Brother = 1
  • Son = 0
• public class Father_Pattern : Template
  • public Father_Pattern()
• public class Files_Pattern : Pattern<Name>
  • public Files_Pattern(Name source)
• public sealed class Full_Equation : Equation
  • public Full_Equation()
• public interface IAbsolute
  • bool BeEmpty { get; }
  • bool BeUnique { get; }
• public interface IComponent : IName, IBe, IRoot, IDisposable
  • void Empty()
  • void Hide()
• public interface IFamily<entity>
  • entity Father { get; }
  • IEnumerable<entity> Instances { get; }
• public interface IInternal
• public interface IIo
• public interface IKernel<entity> : IValue<entity>
• public interface IMessage
  • void Error(string error)
  • void Show(string message)
• public interface IModel
• public interface INames
• public interface INexts<entity>
• public enum Interface
  • IConcept = 0
  • IName = 1
• public interface Inumerable<Value>
  • IEnumerable<Name> Names { get; }
• public interface IObjects
  • object[] Parameters { get; }
  • void Set(object parameter)
  • void Set(object[] parameters)
• public interface IRelation<entity>
• public interface IRelative
  • bool BeFirst { get; }
  • bool BeLast { get; }
• public interface ISelect<entity>
  • bool Be_Selected { get; }
  • entity Get(string search)
• public interface ISemantic
  • Property Comparison { get; }
  • IEnumerable<Property> Foreigns { get; }
  • IEnumerable<Property> Functionals { get; }
  • Property Key { get; }
  • Property Get(string name)
• public interface ISet<type>
  • void Set(type other)
• public interface ISkill<result>
  • result Result { get; }
  • void Execute(string name)
• public interface IStart
  • void Start()
• public interface ITarget<entity>
  • entity Target { get; }
• public interface ITemplate
  • Pattern<IName> Pattern { get; }
  • Template Prefix { get; }
  • Template Suffix { get; }
• public interface IValue<entity>
  • entity Value { get; }
• public static class Name2
  • public static string FatherName(this string name)
  • public static string FirstName(this string name)
  • public static string Trim(this string brute)
• public class Parameter<entity> : Concept<entity, IName>
  • public Parameter()
  • public Parameter(string name)
  • public Parameter(entity entity)
  • public Parameter(object parameter)
• public class Process : Concept<Process, Url>
  • public Process()
  • public Process(Url url)
• public class Property_Argument : Argument<PropertyChangedEventArgs>
  • public Property_Argument(string name)
• public class SBracket : Template
  • public SBracket()
• public class Start
  • public Start(object target)
• public class StartInfo : Concept<ProcessStartInfo, IName>
  • public StartInfo()
  • public StartInfo(Name Object)
• public class Value_Pattern : Template
  • public Value_Pattern()

Fozzy.Kernel.Object

• public interface IDescendant<son, grandson> : ISon<son>, IGrandSon<grandson>
• public interface IGrandSon<Value>
• public interface ISon<Value>

Fozzy.Object

• public class _Brush<brush> : Concept<brush, Color> where brush : Brush
• public class Absolute : Uri
• public class Adapter : One_Many<OleDbDataAdapter, DataSet>
• public class _Adapter : Concept<OleDbDataAdapter, DataSet>
  • public DataTable Table { get; }
  • public _Adapter(Command command)
• public class _DataRow<reference> : Source<DataRow, DataColumn, reference> where reference : IConcept
  • public _DataRow(DataRow row)
• public class _Family<entity> : Multiple<entity, entity>, IFamily<entity> where entity : IConcept
  • public entity Father { get; }
  • public entity First_Born { get; }
  • public _Family(entity source)
  • public _Family(entity source, IEnumerable<entity> ns)
• public abstract class _Father<entity> : _Family<entity> where entity : IConcept
  • public abstract IEnumerable<entity> Instances { get; }
  • public _Father(entity source)
• public abstract class _Relation : Pair<Name>
  • public abstract Boolean Be_Opposable { get; }
  • public abstract Trilean Be_Reflexive { get; }
  • public abstract Trilean Be_Symetric { get; }
  • public abstract Trilean Be_Transitive { get; }
  • public abstract nature Nature { get; }
  • public _Relation(Name first, Name second)
• public class All<reference> : Select<reference> where reference : IConcept
  • public All(OleDbConnection connection)
  • public All(DbConnection connection)
• public class Argument<entity> : One<entity> where entity : EventArgs
• public class Blob : File_Stream
• public class Builder : One<StringBuilder>
• public class Change<item> : One<item>
• public class Changed<entity> : EventArgs
• public class Close : Ternary
• public class Color : One<Color>
• public class Binding<data> : Concept<Binding, IName>
  • public Binding()
  • public Binding(data graphData)
• public class Bitmap : Concept<Bitmap, IName>
  • public Bitmap()
  • public Bitmap(string name)
  • public Bitmap(File file)
  • public Bitmap(Url url)
• public class Column : Concept<DataColumn, IName>
  • public Column(object col)
  • public void Set(Property prop)
  • public void Set(Property prop)
• public class Column_Pattern : Template
  • public Column_Pattern(string source)
  • public Column_Pattern()
• public class Columner<iname> : Archetype<iname, Column> where iname : IOne
• public class Columns : Collection<DataColumnCollection, DataColumn, Column>
• public class Columns<reference> : Objects<Column> where reference : IConcept
  • public Type Type { get; }
  • public _Type Type { get; }
• public class Comma : Separator
• public class Command : Concept<OleDbCommand, Phrase>, ICommand
• public abstract class Command<reference> : Multiple<OleDbConnection, reference> where reference : IConcept
  • public DataTable DataTable { get; }
  • public Table Table { get; }
• public class Concept<one> : Concept<one, IRelation> where one : IOne
• public class Connection<ole> : One_Many<ole, Command>, IGate where ole : DbConnection
• public class Cube : Multiple<_Type, IRelation>
  • public Cube(Type type)
  • public Cube(_Type type)
• public class Data : Directory
• public class DataRow<reference> : Collection<DataColumnCollection, DataColumn, Column> where reference : IOne
• public class DataSet : Concept<DataSet, Table>
  • public Table Table { get; }
  • public DataTable Table { get; }
• public abstract class Dis : Boolean
• public class Dispatcher : Concept<DispatcherTimer, Boolean>
• public class Disposer : Dis
• public class Doer<_Do, _Undo> : Pair<_Do, _Undo> where _Do : Ternary where _Undo : Ternary
• public class Doing : Story
• public class Done : Story
• public class Dependencies : Objects<Dependency>
  • public Dependencies(_Type type)
• public class Dependency : Concept<DependencyProperty, IName>
  • public Dependency(Property prop, Type owner)
  • protected virtual void Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)
• public class Deriveds<entity> : Multiple<object, entity> where entity : IConcept
  • public Deriveds(object target)
• public class Ecart : Column
  • public Ecart()
  • public Ecart(DataRowCollection rows, Property Base, Property comparer)
  • public void Execute(DataRow row, Property Base, Property Comparison)
  • public void Format(DataGridViewCellFormattingEventArgs args)
• public class Ellapse : One_Many<DateTime, MilliSeconds>
• public class Empty : Template
• public class Equation : Chunk
• public class Equation_Prefix2 : Template
• public class Equation_Suffix2 : Template
• public class Father_Pattern : Template
• public class Files_Pattern : Pattern<Name>
• public class Float : Numeric<float>
• public abstract class Functionals<One, collection, Many, Final> : Multiple<One, collection, Many> where collection : IEnumerable where Many : IOne
• public class Heart<target> : Concept<target, Dispatcher> where target : IRegular
• public interface IAbsolute
• public class Identifier : Columner<Identifier>
• public interface IDeployable : IRythmable, IActionable, IConcept, IBase, IName, IBe<string>, IFile, IDisposable
• public interface IDispose : IDisposable
• public interface IElement
• public interface IFinish
• public interface IGate
• public interface IHave<entity>
• public interface IInstance : IOne, IElement, IBe<XElement>, IType, IBe<Type>, IName, IBe<string>, IObject, IBe<object>
• public class FileRelation : Link
  • public FileRelation(Property source, Property target)
• public interface ILink
  • Link Relation { get; }
• public interface Inumerable<Value>
• public interface INumeric
• public interface IPair<type>
• public interface IPlural<type> where type : IOne
• public interface IRegular
• public interface IRelative
• public interface IReversable : IActionable, IConcept, IBase, IName, IBe<string>, IFile, IDisposable
• public interface IRythmable : IActionable, IConcept, IBase, IName, IBe<string>, IFile, IDisposable
• public interface ISelectable
• public interface ISerialize
• public interface ISet
• public interface ISkill
• public interface ISynchronisable : IOne, IElement, IBe<XElement>, IType, IBe<Type>, IName, IBe<string>, IObject, IBe<object>
• public interface ITuple<entity> : IOne, IElement, IBe<XElement>, IType, IBe<Type>, IName, IBe<string>, IObject, IBe<object>, IDisposable
• public interface ITuples
• public class Level : Integer
• public abstract class Link : Pair<Property>, IRelation<Property>
  • public abstract nature Nature { get; }
  • public Link(Property source, Property target)
• public class Long : Dispatcher
• public enum manner
• public class Memory_Stream : Stream
• public class Message : String
• public class MilliSeconds : Integer
• public class Multiple<One> : Multiple<One, One> where One : IOne
• public class Multiple<One, part> : Objects<One, part> where part : IOne
• public abstract class Multiple<One, collection, Many> : One_Many<One, Many> where collection : IEnumerable where Many : IOne
• public class Namer : Columner<Name>
• public abstract class Nexts<father, son> : Multiple<father, son> where father : IOne where son : IOne
• public class Objects<entity> : Systems<entity> where entity : IOne
• public abstract class Objects<One, part> : Systems<One, part> where part : IOne
• public class Open : Ternary
• public class Opener : Doer<Open, Close>
• public class Parameter<entity> : One<entity>
• public class Parenthesis : Wrap
• public class Ole : Concept<OleDbConnection, Command>
  • public Command Command { get; }
  • public OleDbConnection Connection { get; }
  • public DataTable DataTable { get; }
  • public Ole(Sentence sentence, OleDbConnection connection)
  • public Ole(string table, OleDbConnection connection)
  • protected virtual void Create()
• public class Position : Pair<Integer>
  • public Position(Integer x, Integer y)
  • public Integer X { get; }
  • public Integer Y { get; }
• public class Position0 : Name
• public class Position1 : Name
• public class Process : One_Many<Process, Url>
• public class Property_Argument : Argument<PropertyChangedEventArgs>
• public class Random : Concept<Random, Integer>
• public class Read : File_Stream
• public class Relative : Uri
• public class Row : One_Many<DataRow, Column>
• public class Property : Property
  • public bool Be_By_Column { get; }
  • public bool Be_On_Next { get; }
  • public Column Column { get; }
  • public object Default_Value { get; }
  • public Link Relation { get; }
  • public Property(PropertyInfo prop)
  • public Property(Property prop)
  • public Property(object target, Name name)
  • public void Set(object target, File file)
  • public void Set(object target, Property prop)
• public class PropertyRelation : Link
  • public PropertyRelation(Property source)
• public class Row<reference> : Concept<DataRow, IName> where reference : IConcept
  • public Row(Row row, Row nextRow)
  • public Row(DataRow row, DataRow nextRow)
  • public Row(DataRow row, IOne other)
  • public void Set(DataRow nextRow)
  • public Row(DataRow row, IConcept other)
• public class Rows : Collection<DataRowCollection, DataRow, Row>
• public class Rythm<One, Many> : Concept<Multiple<One, Many>, Timer> where Many : IOne
• public class Semi_Column : Separator
• public class Serialization_Exception : Exception
• public class Size : Space
• public class Solid : _Brush<SolidColorBrush>
• public class Space : Pair<Integer>
• public class StartInfo : One<ProcessStartInfo>
• public class Story : Concept<Storyboard, Boolean>
• public abstract class Select<reference> : Command<reference> where reference : IConcept
  • public Select(OleDbConnection connection)
• public class SonRelation : Link
  • public SonRelation(Property source, Property target)
• public class Systems<entity> : Many<entity> where entity : IOne
• public abstract class Systems<One, Many> : One_Many<One, Many> where Many : IOne
• public class Table : Concept<DataTable, IName>
  • public IEnumerable<Column> Columns { get; }
  • public DataColumnCollection Columns { get; }
  • public DataRow New { get; }
  • public IEnumerable<Row> Rows { get; }
  • public IEnumerable<DataColumn> Sources { get; }
  • public DataRow Row { get; }
  • public DataRowCollection Rows { get; }
  • public Table(DbConnection connection)
  • public void Add(DataColumn col)
• public class Table<entity> : Multiple<Table, entity> where entity : IConcept
  • public IEnumerable<Column> Columns { get; }
  • public DataColumnCollection Columns { get; }
  • public virtual Property Key { get; }
  • public virtual Property Key { get; }
  • public IEnumerable<Row> Rows { get; }
  • public DataRowCollection Rows { get; }
  • public void ReName(Type type)
  • public void ReName(_Type type)
• public class Tag : Concept<Match, Group>
• public class Ternary : Pair<Story>
• public class Timer : Dispatcher
• public class Triple_Template : Template
• public class Url : Name
• public abstract class Wrap : Chunk