Enhanced C#
Language of your choice: library documentation

Documentation moved to ecsharp.net

GitHub doesn't support HTTP redirects, so you'll be redirected in 3 seconds.

 All Classes Namespaces Functions Variables Enumerations Enumerator Properties Events Pages
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12345]
 NLeMPThe lexical macro processor. Main classes: LeMP.Compiler and LeMP.MacroProcessor.
 NPreludeDefines prelude macros, which are predefined macros that normally do not have to be explicitly imported before use (in LES or EC#).
 CCompilerA class that helps you invoke MacroProcessor on on a set of source files, given a set of command-line options.
 CContainsMacrosAttributeMarks a class to be searched for macros.
 CIMacroContextThis interface provides services offered by the lexical macro processor (LeMP).
 CInputOutputFor LeMP: an input file plus per-file options (input and output language) and output code.
 CLexicalMacroAttributeMarks a method as an LEL simple macro.
 CMacroContextStandard extension methods for IMacroContext.
 CMacroInfoData returned from IMacroContext.AllKnownMacros
 CMacroProcessorEncapsulates the LeMP engine, a simple LISP-style macro processor, suitable for running LLLPG and other lexical macros.
 CTestCompilerA simple version of Compiler that takes a single input and produces a StringBuilder. Pre-opens LeMP.Prelude namespace.
 NLoycMain Loyc namespace. This namespace includes all general-purpose code in the Loyc megaproject. It includes the code of Loyc.Essentials.dll and Loyc.Collections.dll (collections, geometry, MiniTest, MessageSink, etc.), and also the code of Loyc.Syntax.dll.
 NCollectionsContains general-purpose interfaces (Loyc.Collections.IListSource{T}, ranges, etc.), collection implementations (Loyc.Collections.DList{T}, Loyc.Collections.WeakValueDictionary{K,V}, etc.), extension methods (Loyc.Collections.LCExt, Loyc.Collections.EnumerableExt, etc.), helper classes (Loyc.Collections.EmptyList{T}, (Loyc.Collections.Repeated{T}, etc.), and adapter classes (Loyc.Collections.ListSlice{T}, Loyc.Collections.BufferedSequence{T}, etc.).
 NGeometryContains math code and data types for processing geometry (points, lines, polygons, etc.). Basic geometry stuff is in Loyc.Essentials.dll, while more advanced algorithms are found in Loyc.Utilities.dll.
 NLLParserGeneratorCode related to LLLPG, the Loyc LL(k) Parser Generator (LLLPG.exe).
 NMathContains general-purpose math algorithms beyond what is provided in the .NET BCL (Base Class Library). Notable class: Math.MathEx.
 NMiniTestA stripped-down NUnit lookalike which allows you to put simple unit tests in an assembly without having to add a reference to NUnit.Framework.dll.
 NSyntaxLoyc.Syntax.dll: contains Loyc trees (Loyc.Syntax.LNode), lexing stuff, LLLPG base classes (BaseParser{T} and BaseLexer), the LES parser and printer, data types related to source code management (e.g. ISourceFile, SourceRange) and other general-purpose code related to the manipulation of syntax
 NThreadingHelper classes for multithreaded code.
 NUtilitiesContains general-purpose classes that are not considered important enough to go directly into the Loyc namespace. Most of the classes in this namespace are defined in Loyc.Utilities.dll.
 CCheckParamHelper methods for checking argument values that throw exceptions when an argument value is not acceptable.
 CConcurrentModificationExceptionAn exception thrown when a data structure is accessed (read or written) by one thread at the same time as it is modified on another thread.
 CConsoleMessageSinkSends all messages to System.Console.WriteLine(), with hard-coded colors for Error, Warning, Note, Verbose, and Detail.
 CExceptionExtExtension methods for exceptions.
 CEzStopwatchA wrapper around Stopwatch with a more convenient interface, currently oriented around measuring milliseconds (TODO: increase similarity to Stopwatch)
 CGContains global functions that don't belong in any specific class.
 CGSymbolThis class produces global symbols.
 CHashTags< ValueT >An implementation of IAttributes that can hold one attribute before allocating any memory for a hashtable. It is intended to be used as a base class but can be used on its own.
 CHolder< T >A trivial class that holds a single value of type T in the Value property.
 CICloneable< out T >Interface for types that can duplicate themselves.
 CIHasLocationThis interface allows an object to declare its "location". It is used by MessageSink.LocationString, which helps convert the "context" of a message into a string.
 CIHasValue< out T >Interface for things that have a Value property.
 CIMessageSinkA general-purpose interface for a class that accepts formatted messages with context information.
 CInvalidStateExceptionAn exception thrown when an object detects that its own state is invalid, or in other words, that an invariant has been violated.
 CIReferenceComparableThis is a tag which indicates that objects of this type are unique; specifically, any two different objects that implement this interface are always unequal, and one object is equal only to itself.
 CITags< T >Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol.
 CLocalizableAttributeI plan to use this attribute someday to gather all the localizable strings in an application. This attribute should be applied to a string function parameter if the method calls Localized() using that parameter as the format string.
 CLocalizeLocalize is a global hook into which a string-mapping localizer can be installed. It is designed to make internationalization exceptionally easy for developers. TODO: expand I18N features based on Mozilla's L20N.
 CLogExceptionAn exception that includes a "context" object as part of a LogMessage structure, typically used to indicate where an error occurred.
 CLogMessageHolds an argument list compatible with IMessageSink.Write. Typically used with MessageHolder.
 CMaybe< T >Same as Nullable{T} except that it behaves like a normal type, i.e. (1) T is allowed to be a reference type and (2) you can nest them, as in Maybe{Maybe{int}}.
 CMemoizedTypeName.NET Framework reflection doesn't offer complete type names for generic types such as "List&lt;int>" (the Type.Name value of that class is "List`1"). Get fills in the gap, and also saves the computed name for fast repeated lookups.
 CMemoizedTypeName< T >MemoizedTypeName<T>.Get() is an alternative to MemoizedTypeName.Get(typeof(T)).
 CMessageFilterA decorator that uses a delegate to accept or ignore messages.
 CMessageHolderA message sink that puts the messages it receives in a list.
 CMessageSinkHolds the default message sink for this thread (Current), Symbols for the common message types, such as Warning and Error, and default instances of ConsoleMessageSink, TraceMessageSink and NullMessageSink.
 CMessageSinkFromDelegateThis helper class lets you implement IMessageSink with one or two delegates (a writer method, and an optional severity filter).
 CMessageSplitterA message sink that sends its messages to a list of other sinks.
 CNoValueNoValue.Value is meant to be used as the value of a property that has "no value", meaning no value is assigned or that the property is meaningless at the current time or in the current context.
 CNullMessageSinkDiscards all messages. However, there is a Count property that increases by one with each message received.
 CPairPair.Create(a, b) is a helper method for making pairs.
 CPair< T1, T2 >A tuple of two values, A and B, in a struct.
 CReadOnlyExceptionAn exception thrown when an attempt is made to modify a read-only object.
 CReferenceComparer< T >An IEqualityComparer{T} based on reference equality
 CSeverityMessageFilterA decorator (wrapper) for IMessageSink that filters out some messages if their Severity is too low, according to the value of the MinSeverity property.
 CStringExtExtension methods for strings, such as SplitAt, Left, Right, Format and USlice.
 CSymbolRepresents a symbol, which is a singleton string that supports fast comparisons and extensible enums.
 CSymbolPoolA collection of Symbols.
 CSymbolPool< SymbolE >This type of SymbolPool helps create more strongly typed Symbols that simulate enums, but provide extensibility. Specifically, it creates SymbolE objects, where SymbolE is some derived class of Symbol.
 CSymbolSetA set of symbols.
 CTraceMessageSinkSends all messages to System.Diagnostics.Trace.WriteLine(string).
 CTriplet< T1, T2, T3 >A tuple of three values (A, B and C) in a struct.
 CTypeExtExtension methods for Type.
 CUStringUString is a slice of a string. It is a wrapper around string that provides a IBRange{T} of 21-bit UCS-4 characters. "U" stands for "Unicode", as in UCS-4, as opposed to a normal string that is UTF-16.
 CValueComparer< T >You'd think the .NET framework would have a built-in method–even a CIL opcode–to bitwise-compare two values. Not supporting bitwise compare is, in my opinion, one of several mind-bogglingly dumb decisions in the CLR. Instead, all you can do is call ValueComparer.Default.Equals(a, b).
 Cvoid.Value represents the sole value of System.Void (called "void" in C#).
 CWeakReferenceExtThe new WeakReference{T} type in .NET 4.5 removes the Target and IsAlive properties. These extension methods restore that traditional functionality, making it easier to transition from the old WeakReference to the new one.
 CWrapperBase< T >Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString().
 CHighlightGroupBundles a group of markers together so that they can be cleared together.
 CLempDemoFormMain form for a multi-file text editor based on ICSharpCode.TextEditor.TextEditorControl.
 CRegionFoldingStrategyThe class to generate the foldings, it implements ICSharpCode.TextEditor.Document.IFoldingStrategy
 CTextEditorSearcherThis class finds occurrances of a search string in a text editor's IDocument... it's like Find box without a GUI.