YamlSerializer
Configuration to customize YAML serialization.
An instance of this class can be passed to the serialization
methods, such as YamlNode.ToYaml(YamlConfig) and
YamlNode.FromYaml(Stream,YamlConfig) or
it can be assigned to YamlNode.DefaultConfig.
If true, all line breaks in the node value are normalized into "\r\n"
(= ) when serialize and line breaks
that are not escaped in YAML stream are normalized into "\n"
(= .
If false, the line breaks are preserved. Setting this option false violates
the YAML specification but sometimes useful. The default is true.
The YAML sepcification requires a YAML parser to normalize every line break that
is not escaped in a YAML stream, into a single line feed "\n" when it parse a YAML stream.
But this is not convenient in some cases, especially under Windows environment, where
the system default line break
is "\r\n" instead of "\n".
This library provides two workarounds for this problem.
One is setting false. It disables the line break
normalization. The line breaks are serialized into a YAML stream as is and
those in the YAML stream are deserialized as is.
Another is setting "\r\n". Then, the YAML parser
normalizes all line breaks into "\r\n" instead of "\n".
Note that although these two options are useful in some cases,
they makes the YAML parser violate the YAML specification.
// A string containing line breaks "\n\r" and "\r".
YamlNode node = "a\r\n b\rcde";
// By default conversion, line breaks are escaped in a double quoted string.
var yaml = node.ToYaml();
// %YAML 1.2
// ---
// "a\r\n\
// \ b\r\
// cde"
// ...
// "%YAML 1.2\r\n---\r\n\"a\\r\\n\\\r\n\ b\\r\\\r\ncde\"\r\n...\r\n"
// Such a YAML stream is not pretty but is capable to preserve
// original line breaks even when the line breaks of the YAML stream
// are changed (for instance, by some editor) between serialization
// and deserialization.
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // still equivalent to the original
// By setting ExplicitlyPreserveLineBreaks false, the output becomes
// much prettier.
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
yaml = node.ToYaml();
// %YAML 1.2
// ---
// |-2
// a
// b
// cde
// ...
// line breaks are nomalized to "\r\n" (= YamlNode.DefaultConfig.LineBreakForOutput)
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\r\ncde\r\n...\r\n"
// line breaks are nomalized to "\n" (= YamlNode.DefaultConfig.LineBreakForInput)
var restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde"
// Disable line break normalization.
YamlNode.DefaultConfig.NormalizeLineBreaks = false;
yaml = node.ToYaml();
// line breaks are not nomalized
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\rcde\r\n...\r\n"
// Unless line breaks in YAML stream is preserved, original line
// breaks can be restored.
restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde" // original line breaks are lost
If true, all s whose text expression contains line breaks
will be presented as double quoted texts, where the line break characters are escaped
by back slash as "\\n" and "\\r". The default is true.
The escaped line breaks makes the YAML stream hard to read, but is required to
prevent the line break characters be normalized by the YAML parser; the YAML
sepcification requires a YAML parser to normalize all line breaks that are not escaped
into a single line feed "\n" when it parse a YAML source.
If the preservation of line breaks are not required, set this value false.
Then, whenever it is possible, the s are presented
as literal style text, where the line breaks are not escaped. This results in
a much prettier output in the YAML stream.
// A string containing line breaks "\n\r" and "\r".
YamlNode node = "a\r\n b\rcde";
// By default conversion, line breaks are escaped in a double quoted string.
var yaml = node.ToYaml();
// %YAML 1.2
// ---
// "a\r\n\
// \ b\r\
// cde"
// ...
// "%YAML 1.2\r\n---\r\n\"a\\r\\n\\\r\n\ b\\r\\\r\ncde\"\r\n...\r\n"
// Such a YAML stream is not pretty but is capable to preserve
// original line breaks even when the line breaks of the YAML stream
// are changed (for instance, by some editor) between serialization
// and deserialization.
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // still equivalent to the original
// By setting ExplicitlyPreserveLineBreaks false, the output becomes
// much prettier.
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
yaml = node.ToYaml();
// %YAML 1.2
// ---
// |-2
// a
// b
// cde
// ...
// line breaks are nomalized to "\r\n" (= YamlNode.DefaultConfig.LineBreakForOutput)
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\r\ncde\r\n...\r\n"
// line breaks are nomalized to "\n" (= YamlNode.DefaultConfig.LineBreakForInput)
var restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde"
// Disable line break normalization.
YamlNode.DefaultConfig.NormalizeLineBreaks = false;
yaml = node.ToYaml();
// line breaks are not nomalized
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\rcde\r\n...\r\n"
// Unless line breaks in YAML stream is preserved, original line
// breaks can be restored.
restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde" // original line breaks are lost
Line break to be used when is presented in YAML stream.
"\r", "\r\n", "\n" are allowed. "\r\n" is defalut.
// A string containing line breaks "\n\r" and "\r".
YamlNode node = "a\r\n b\rcde";
// By default conversion, line breaks are escaped in a double quoted string.
var yaml = node.ToYaml();
// %YAML 1.2
// ---
// "a\r\n\
// \ b\r\
// cde"
// ...
// "%YAML 1.2\r\n---\r\n\"a\\r\\n\\\r\n\ b\\r\\\r\ncde\"\r\n...\r\n"
// Such a YAML stream is not pretty but is capable to preserve
// original line breaks even when the line breaks of the YAML stream
// are changed (for instance, by some editor) between serialization
// and deserialization.
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // still equivalent to the original
// By setting ExplicitlyPreserveLineBreaks false, the output becomes
// much prettier.
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
yaml = node.ToYaml();
// %YAML 1.2
// ---
// |-2
// a
// b
// cde
// ...
// line breaks are nomalized to "\r\n" (= YamlNode.DefaultConfig.LineBreakForOutput)
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\r\ncde\r\n...\r\n"
// line breaks are nomalized to "\n" (= YamlNode.DefaultConfig.LineBreakForInput)
var restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde"
// Disable line break normalization.
YamlNode.DefaultConfig.NormalizeLineBreaks = false;
yaml = node.ToYaml();
// line breaks are not nomalized
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\rcde\r\n...\r\n"
// Unless line breaks in YAML stream is preserved, original line
// breaks can be restored.
restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde" // original line breaks are lost
The YAML parser normalizes line breaks in a YAML stream to this value.
"\n" is default, and is the only valid value in the YAML specification. "\r" and "\r\n" are
allowed in this library for convenience.
To suppress normalization of line breaks by YAML parser, set
false, though it is also violate the YAML specification.
The YAML sepcification requires a YAML parser to normalize every line break that
is not escaped in a YAML stream, into a single line feed "\n" when it parse a YAML stream.
But this is not convenient in some cases, especially under Windows environment, where
the system default line break
is "\r\n" instead of "\n".
This library provides two workarounds for this problem.
One is setting false. It disables the line break
normalization. The line breaks are serialized into a YAML stream as is and
those in the YAML stream are deserialized as is.
Another is setting "\r\n". Then, the YAML parser
normalizes all line breaks into "\r\n" instead of "\n".
Note that although these two options are useful in some cases,
they makes the YAML parser violate the YAML specification.
// A string containing line breaks "\n\r" and "\r".
YamlNode node = "a\r\n b\rcde";
// By default conversion, line breaks are escaped in a double quoted string.
var yaml = node.ToYaml();
// %YAML 1.2
// ---
// "a\r\n\
// \ b\r\
// cde"
// ...
// "%YAML 1.2\r\n---\r\n\"a\\r\\n\\\r\n\ b\\r\\\r\ncde\"\r\n...\r\n"
// Such a YAML stream is not pretty but is capable to preserve
// original line breaks even when the line breaks of the YAML stream
// are changed (for instance, by some editor) between serialization
// and deserialization.
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
var restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // still equivalent to the original
// By setting ExplicitlyPreserveLineBreaks false, the output becomes
// much prettier.
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
yaml = node.ToYaml();
// %YAML 1.2
// ---
// |-2
// a
// b
// cde
// ...
// line breaks are nomalized to "\r\n" (= YamlNode.DefaultConfig.LineBreakForOutput)
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\r\ncde\r\n...\r\n"
// line breaks are nomalized to "\n" (= YamlNode.DefaultConfig.LineBreakForInput)
var restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde"
// Disable line break normalization.
YamlNode.DefaultConfig.NormalizeLineBreaks = false;
yaml = node.ToYaml();
// line breaks are not nomalized
// "%YAML 1.2\r\n---\r\n|-2\r\n a\r\n b\rcde\r\n...\r\n"
// Unless line breaks in YAML stream is preserved, original line
// breaks can be restored.
restored = YamlNode.FromYaml(yaml)[0];
// "a\r\n b\rcde" // equivalent to the original
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
restored = YamlNode.FromYaml(yaml)[0];
// "a\n b\ncde" // original line breaks are lost
If true, tag for the root node is omitted by .
If true, the verbatim style of a tag, i.e. !< > is avoided as far as possible.
Add a custom tag resolution rule.
Type of value.
Tag for the value.
Pattern to match the value.
Method that decode value from
data after matching by .
Method that encode value to .
Add an ability of instantiating an instance of a class that has no default constructer.
Type of the object that is activated by this .
A delegate that creates an instance of .
var serializer= new YamlSerializer();
var yaml =
@"%YAML 1.2
---
!System.Drawing.SolidBrush
Color: Red
...
";
SolidBrush b = null;
try {
b = (SolidBrush)serializer.Deserialize(yaml)[0];
} catch(MissingMethodException) {
// SolidBrush has no default constructor!
}
YamlNode.DefaultConfig.AddActivator<SolidBrush>(() => new SolidBrush(Color.Black));
// Now the serializer knows how to activate an instance of SolidBrush.
b = (SolidBrush)serializer.Deserialize(yaml)[0];
Assert.AreEqual(b.Color, Color.Red);
Gets or sets CultureInfo with which the .NET native values are converted
to / from string. Currently, this is not to be changed from CultureInfo.InvariantCulture.
Abstract base class of YAML data nodes.
See , and
for actual data classes.
YAML data model
See http://yaml.org/ for the official definition of
Information Models of YAML.
YAML data structure is defined as follows.
Note that this does not represents the text syntax of YAML text
but does logical data structure.
yaml-stream ::= yaml-document*
yaml-document ::= yaml-directive* yaml-node
yaml-directive ::= YAML-directive | TAG-directive | user-defined-directive
yaml-node ::= yaml-scalar | yaml-sequence | yaml-mapping
yaml-scalar ::= yaml-tag yaml-value
yaml-sequence ::= yaml-tag yaml-node*
yaml-mapping ::= yaml-tag ( yaml-node yaml-node )*
yaml-tag ::= yaml-global-tag yaml-local-tag
yaml-global-tag ::= "tag:" taggingEntity ":" specific [ "#" fragment ]
yaml-local-tag ::= "!" yaml-local-tag-name
Namely,
A YAML stream consists of zero or more YAML documents.
A YAML documents have zero or more YAML directives and a root YAML node.
A YAML directive is either YAML-directive, TAG-directive or user-defined-directive.
A YAML node is either YAML scalar, YAML sequence or YAML mapping.
A YAML scalar consists of a YAML tag and a scalar value.
A YAML sequence consists of a YAML tag and zero or more child YAML nodes.
A YAML mapping cosists of a YAML tag and zero or more key/value pairs of YAML nodes.
A YAML tag is either a YAML global tag or a YAML local tag.
A YAML global tag starts with "tag:" and described in the "tag:" URI scheme defined in RFC4151.
A YAML local tag starts with "!" with a YAML local tag name
// Construct YAML node tree
YamlNode node =
new YamlSequence( // !!seq node
new YamlScalar("abc"), // !!str node
new YamlScalar("!!int", "123"), // !!int node
new YamlScalar("!!float", "1.23"), // !!float node
new YamlSequence( // nesting !!seq node
new YamlScalar("def"),
new YamlScalar("ghi")
),
new YamlMapping( // !!map node
new YamlScalar("key1"), new YamlScalar("value1"),
new YamlScalar("key2"), new YamlScalar("value2"),
new YamlScalar("key3"), new YamlMapping( // nesting !!map node
new YamlScalar("value3key1"), new YamlScalar("value3value1")
),
new YamlScalar("key4"), new YamlScalar("value4")
)
);
// Convert it to YAML stream
string yaml = node.ToYaml();
// %YAML 1.2
// ---
// - abc
// - 123
// - 1.23
// - - def
// - ghi
// - key1: value1
// key2: value2
// key3:
// value3key1: value3value1
// key4: value4
// ...
// Load the YAML node from the YAML stream.
// Note that a YAML stream can contain several YAML documents each of which
// contains a root YAML node.
YamlNode[] nodes = YamlNode.FromYaml(yaml);
// The only one node in the stream is the one we have presented above.
Assert.AreEqual(1, nodes.Length);
YamlNode resotred = nodes[0];
// Check if they are equal to each other.
Assert.AreEquel(node, restored);
// Extract sub nodes.
var seq = (YamlSequence)restored;
var map = (YamlMapping)seq[4];
var map2 = (YamlMapping)map[new YamlScalar("key3")];
// Modify the restored node tree
map2[new YamlScalar("value3key1")] = new YamlScalar("value3value1 modified");
// Now they are not equal to each other.
Assert.AreNotEquel(node, restored);
YamlNode class
is an abstract class that represents a YAML node.
In reality, a is either , or
.
All has property that denotes
the actual data type represented in the YAML node.
Default Tag value for , or are
"tag:yaml.org,2002:str", "tag:yaml.org,2002:seq", "tag:yaml.org,2002:map".
Global tags that starts with "tag:yaml.org,2002:" ( =
YamlNode.DefaultTagPrefix) are defined in the YAML tag repository at
http://yaml.org/type/. In this library, such a tags can be also
represented in a short form that starts with "!!", like "!!str", "!!seq" and "!!map".
Tags in the formal style and the shorthand form can be converted to each other by the static methods of
and .
In addition to these three basic tags, this library uses "!!null", "!!bool", "!!int",
"!!float" and "!!timestamp" tags, by default.
s can be read from a YAML stream with ,
, and
static methods. Since a YAML stream generally consist of multiple
YAML documents, each of which has a root YAML node, these methods return an array of
that is contained in the stream.
s can be written to a YAML stream with ,
, and
.
The way of serialization can be configured in some aspects. The custom settings are specified
by an instance of class. The serialization methods introduced above has
overloaded styles that accepts instance to customize serialization.
It is also possible to change the default serialization method by modifying
YamlNode.DefaultConfig static property.
A has property, which holds the string expression
of the node value.
A implements IList<YamlNode>
interface to access the child nodes.
implements
IDictionary<YamlNode,YamlNode> interface
to access the key/value pairs under the node.
Implicit conversion from C# native object to YamlScalar
Implicit cast operators from , , ,
and to is defined. Thus, anytime
is required in C# source, naked scalar value can be written. Namely,
methods of and accept such C# native types
as arguments in addition to types.
var map = new YamlMapping();
map["Time"] = DateTime.Now; // implicitly converted to YamlScalar
Assert.IsTrue(map.ContainsKey(new YamlScalar("Time")));
Assert.IsTrue(map.ContainsKey("Time")); // implicitly converted to YamlScalar
Equality of YamlNodes
Equality of s are evaluated on the content base. Different
objects that have the same content are evaluated to be equal. Use method for
equality evaluation.
In detail, two s are logically equal to each other when the
and its child nodes have the same contents ( and )
and their node graph topology is exactly same.
YamlNode a1 = "a"; // implicit conversion
YamlNode a2 = "a"; // implicit conversion
YamlNode a3 = new YamlNode("!char", "a");
YamlNode b = "b"; // implicit conversion
Assert.IsTrue(a1 != a2); // different objects
Assert.IsTrue(a1.Equals(a2)); // different objects having same content
Assert.IsFalse(a1.Equals(a3)); // Tag is different
Assert.IsFalse(a1.Equals(b)); // Value is different
var s1 = new YamlMapping(a1, new YamlSequence(a1, a2));
var s2 = new YamlMapping(a1, new YamlSequence(a2, a1));
var s3 = new YamlMapping(a2, new YamlSequence(a1, a2));
Assert.IsFalse(s1.Equals(s2)); // node graph topology is different
Assert.IsFalse(s1.Equals(s3)); // node graph topology is different
Assert.IsTrue(s2.Equals(s3)); // different objects having same content and node graph topology
Example 2.27 in YAML 1.2 specification
// %YAML 1.2
// ---
// !<tag:clarkevans.com,2002:invoice>
// invoice: 34843
// date : 2001-01-23
// bill-to: &id001
// given : Chris
// family : Dumars
// address:
// lines: |
// 458 Walkman Dr.
// Suite #292
// city : Royal Oak
// state : MI
// postal : 48046
// ship-to: *id001
// product:
// - sku : BL394D
// quantity : 4
// description : Basketball
// price : 450.00
// - sku : BL4438H
// quantity : 1
// description : Super Hoop
// price : 2392.00
// tax : 251.42
// total: 4443.52
// comments:
// Late afternoon is best.
// Backup contact is Nancy
// Billsmer @ 338-4338.
// ...
var invoice = new YamlMapping(
"invoice", 34843,
"date", new DateTime(2001, 01, 23),
"bill-to", new YamlMapping(
"given", "Chris",
"family", "Dumars",
"address", new YamlMapping(
"lines", "458 Walkman Dr.\nSuite #292\n",
"city", "Royal Oak",
"state", "MI",
"postal", 48046
)
),
"product", new YamlSequence(
new YamlMapping(
"sku", "BL394D",
"quantity", 4,
"description", "Basketball",
"price", 450.00
),
new YamlMapping(
"sku", "BL4438H",
"quantity", 1,
"description", "Super Hoop",
"price", 2392.00
)
),
"tax", 251.42,
"total", 4443.52,
"comments", "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338."
);
invoice["ship-to"] = invoice["bill-to"];
invoice.Tag = "tag:clarkevans.com,2002:invoice";
invoice.ToYamlFile("invoice.yaml");
// %YAML 1.2
// ---
// !<tag:clarkevans.com,2002:invoice>
// invoice: 34843
// date: 2001-01-23
// bill-to: &A
// given: Chris
// family: Dumars
// address:
// lines: "458 Walkman Dr.\n\
// Suite #292\n"
// city: Royal Oak
// state: MI
// postal: 48046
// product:
// - sku: BL394D
// quantity: 4
// description: Basketball
// price: !!float 450
// - sku: BL4438H
// quantity: 1
// description: Super Hoop
// price: !!float 2392
// tax: 251.42
// total: 4443.52
// comments: Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.
// ship-to: *A
// ...
Initialize a node.
YAML Tag for this node, which represents the type of node's value.
The property is returned in a shorthand style.
Serves as a hash function for a particular type.
Hash code is calculated using Tag and Value properties.
Hash code
Return the hash code.
The returned value will be cached until is called.
Hash code
Call this function when the content of the node is changed.
Returns true if is of same type as the and
its content is also logically same.
Two 's are logically equal when the and its child nodes
have the same contents ( and )
and their node graph topology is exactly same as the other.
var a1 = new YamlNode("a");
var a2 = new YamlNode("a");
var a3 = new YamlNode("!char", "a");
var b = new YamlNode("b");
Assert.IsTrue(a1 != a2); // different objects
Assert.IsTrue(a1.Equals(a2)); // different objects having same content
Assert.IsFalse(a1.Equals(a3)); // Tag is different
Assert.IsFalse(a1.Equals(b)); // Value is different
var s1 = new YamlMapping(a1, new YamlSequence(a1, a2));
var s2 = new YamlMapping(a1, new YamlSequence(a2, a1));
var s3 = new YamlMapping(a2, new YamlSequence(a1, a2));
Assert.IsFalse(s1.Equals(s2)); // node graph topology is different
Assert.IsFalse(s1.Equals(s3)); // node graph topology is different
Assert.IsTrue(s2.Equals(s3)); // different objects having same content and node graph topology
Object to be compared.
True if the logically equals to the ; otherwise false.
Returns true if is of same type as the and
its content is also logically same.
Node to be compared.
Node repository holds the nodes that already appeared and
the corresponding node in the other node tree.
true if they are equal to each other.
Returns true if is of same type as the and
its Tag is same as the node. It returns true for if they
both already appeared in the node trees and were compared.
Node to be compared.
Node repository holds the nodes that already appeared and
the corresponding node in the other node tree.
true if they already appeared in the node tree and were compared.
true if they are equal to each other.
Returns a that represents the current .
A that represents the current
Convert to a YAML text.
YAML stream.
Convert to a YAML text.
YAML stream.
YAML configuration to customize serialization.
Convert to a YAML text and save it to .
to output.
Convert to a YAML text and save it to .
to output.
YAML configuration to customize serialization.
Convert to a YAML text and save it to .
to output.
Convert to a YAML text and save it to .
to output.
YAML configuration to customize serialization.
Convert to a YAML text and save it to the file.
Name of the file to output
Convert to a YAML text and save it to the file.
Name of the file to output
YAML configuration to customize serialization.
Convert YAML text to a list of .
YAML text
YAML nodes
Convert YAML text to a list of .
YAML text
YAML nodes
YAML configuration to customize serialization.
Convert YAML text to a list of .
from which YAML document is read.
YAML nodes
Convert YAML text to a list of .
from which YAML document is read.
YAML nodes
YAML configuration to customize serialization.
Convert YAML text to a list of .
from which YAML document is read.
YAML nodes
Convert YAML text to a list of .
from which YAML document is read.
YAML nodes
YAML configuration to customize serialization.
Convert YAML text to a list of .
YAML File Name
YAML nodes
Convert YAML text to a list of .
YAML File Name
YAML nodes
YAML configuration to customize serialization.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from to .
Value to be converted.
Conversion result.
Convert shorthand tag starting with "!!" to the formal style that starts with "tag:yaml.org,2002:".
When starts with "!!", it is converted into formal style.
Otherwise, is returned as is.
var tag = YamlNode.DefaultTagPrefix + "int"; // -> "tag:yaml.org,2002:int"
tag = YamlNode.ShorthandTag(tag); // -> "!!int"
tag = YamlNode.ExpandTag(tag); // -> "tag:yaml.org,2002:int"
Tag in the shorthand style.
Tag in formal style.
Convert a formal style tag that starts with "tag:yaml.org,2002:" to
the shorthand style that starts with "!!".
When contains YAML standard types, it is converted into !!xxx style.
Otherwise, is returned as is.
var tag = YamlNode.DefaultTagPrefix + "int"; // -> "tag:yaml.org,2002:int"
tag = YamlNode.ShorthandTag(tag); // -> "!!int"
tag = YamlNode.ExpandTag(tag); // -> "tag:yaml.org,2002:int"
Tag in formal style.
Tag in compact style.
Position in a YAML document, where the node appears.
Both and sets this property.
When the node appeared multiple times in the document, this property returns the position
where it appeared for the first time.
Position in a YAML document, where the node appears.
Both and sets this property.
When the node appeared multiple times in the document, this property returns the position
where it appeared for the first time.
Temporary data, transfering information between YamlRepresenter and YamlPresenter.
YAML Tag for this node, which represents the type of node's value.
YAML standard types has tags in a form of "tag:yaml.org,2002:???". Well known tags are
tag:yaml.org,2002:null, tag:yaml.org,2002:bool, tag:yaml.org,2002:int, tag:yaml.org,2002:str,
tag:yaml.org,2002:map, tag:yaml.org,2002:seq, tag:yaml.org,2002:float and tag:yaml.org,2002:timestamp.
Invoked when the node's content or its childrens' content was changed.
Gets YAML's default tag prefix.
"tag:yaml.org,2002:"
Gets or sets the default configuration to customize serialization of .
Remember the order of appearance of nodes. It also has ability of rewinding.
Represents a scalar node in a YAML document.
var string_node = new YamlNode("abc");
Assert.AreEqual("!!str", string_node.ShorthandTag());
var int_node1= new YamlNode(YamlNode.DefaultTagPrefix + "int", "1");
Assert.AreEqual("!!int", int_node1.ShorthandTag());
// shorthand tag style can be specified
var int_node2= new YamlNode("!!int", "1");
Assert.AreEqual(YamlNode.DefaultTagPrefix + "int", int_node1.Tag);
Assert.AreEqual("!!int", int_node1.ShorthandTag());
// or use implicit conversion
YamlNode int_node3 = 1;
// YamlNodes Equals to another node when their values are equal.
Assert.AreEqual(int_node1, int_node2);
// Of course, they are different if compaired by references.
Assert.IsTrue(int_node1 != int_node2);
Create empty string node.
Initialize string node that has as its content.
Value of the node.
Create a scalar node with arbitral tag.
Tag to the node.
Value of the node.
Initialize an integer node that has as its content.
Initialize a float node that has as its content.
Initialize a bool node that has as its content.
Initialize a timestamp node that has as its content.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from string to .
Value to be converted.
Conversion result.
Implicit conversion from to .
Value to be converted.
Conversion result.
Call this function when the content of the node is changed.
Returns the hash code.
The returned value will be cached until is called.
Hash code
String expression of the node value.
When the node has YAML's standard scalar type, the native object corresponding to
it can be got from this property. To see if this property contains a valid data,
refer to .
This property is not available. See .
This property is available when . contains
an entry for the nodes tag and defines how to decode the property into native objects.
When this property is available, equality of the scalar node is evaluated by comparing the
properties by the language default equality operator.
Gets if contains a valid content.
Abstract base class of that have child nodes.
and inherites from this class.
Calculate hash code from property and all child nodes.
The result is cached.
Hash value for the object.
Calculates the hash code for a collection object. This function is called recursively
on the child objects with the sub cache code repository for the nodes already appeared
in the node tree.
The cache code for the path where this node was found.
Repository of the nodes that already appeared in the node tree.
Sub hash code for the nodes can be refered to from this dictionary.
Represents a mapping node in a YAML document.
Use IDictionary<YamlNode,YamlNode> interface to
manipulate child key/value pairs.
Child items can be accessed via IDictionary<YamlNode, YamlNode> interface.
Note that mapping object can not contain multiple keys with same value.
// Create a mapping.
var map1 = new YamlMapping(
// (key, value) pairs should be written sequential
new YamlScalar("key1"), new YamlScalar("value1"),
"key2", "value2" // implicitely converted to YamlScalar
);
// Refer to the mapping.
Assert.AreEqual( map1[new Scalar("key1")], new YamlScalar("value1") );
Assert.AreEqual( map1["key1"], "value1" );
// Add an entry.
map1.Add( "key3", new YamlSequence( "value3a", "value3b" ) );
// Create another mapping.
var map2 = new YamlMapping(
"key1", "value1",
"key2", "value2",
"key3", new YamlSequence( "value3a", "value3b" )
);
// Mappings are equal when they have objects that are equal to each other.
Assert.IsTrue( map1.Equals( map2 ) );
Calculates the hash code for a collection object. This function is called recursively
on the child objects with the sub cache code repository for the nodes already appeared
in the node tree.
The cache code for the path where this node was found.
Repository of the nodes that already appeared in the node tree.
Sub hash code for the nodes can be refered to from this dictionary.
Create a YamlMapping that contains in it.
// Create a mapping.
var map1 = new YamlMapping(
// (key, value) pairs should be written sequential
new YamlScalar("key1"), new YamlScalar("value1"),
new YamlScalar("key2"), new YamlScalar("value2")
);
Even number of arguments are expected.
(key, value) pairs are written sequential.
Enumerate child nodes.
Inumerator that iterates child nodes
Adds an element with the provided key and value.
or is a null reference.
An element with the same key already exists.
The node to use as the key of the element to add.
The node to use as the value of the element to add.
Determines whether the contains an element with the specified key.
The key to locate in the .
is a null reference
true if the contains an element with the key that is equal to the specified value; otherwise, false.
Removes the element with the specified key from the .
The key of the element to remove.
true if the element is successfully removed; otherwise, false. This method also returns false if key was not found in the original .
Gets the value associated with the specified key.
The key whose value to get.
When this method returns, the value associated with the specified key, if the key is found;
otherwise, the default value for the type of the value parameter. This parameter is passed uninitialized.
true if the object that implements contains an element with the specified key; otherwise, false.
Removes all entries from the .
Determines whether the contains a specific value.
The object to locate in the .
true if item is found in the otherwise, false.
Returns an enumerator that iterates through the .
An enumerator that iterates through the .
Gets an ICollection<YamlNode> containing the keys of the .
Gets an ICollection<YamlNode> containing the values of the .
Gets or sets the element with the specified key.
The key of the element to get or set.
The element with the specified key.
key is a null reference
The property is retrieved and key is not found.
Returns the number of entries in a .
Represents a sequence node in a YAML document.
Use IList<YamlNode> interface
to manipulate child nodes.
Create a sequence node that has as its child.
Child nodes of the sequence.
Performs application-defined tasks associated with freeing, releasing, or
resetting unmanaged resources.
Calculates the hash code for a collection object. This function is called recursively
on the child objects with the sub cache code repository for the nodes already appeared
in the node tree.
The cache code for the path where this node was found.
Repository of the nodes that already appeared in the node tree.
Sub hash code for the nodes can be refered to from this dictionary.
Determines the index of a specific child node in the .
If an node appears multiple times in the sequence, the IndexOf method always returns the first instance found.
The child node to locate in the .
The index of if found in the sequence; otherwise, -1.
Inserts an item to the at the specified .
The zero-based index at which should be inserted.
The node to insert into the .
is not a valid index in the
.
If equals the number of items in the ,
then is appended to the sequence.
The nodes that follow the insertion point move down to accommodate the new node.
Removes the item at the specified index.
The zero-based index of the node to remove.
is not a valid index in the .
The nodes that follow the removed node move up to occupy the vacated spot.
Adds an item to the .
The node to add to the .
Removes all nodes from the .
Determines whether a sequence contains a child node that equals to the specified
by using the default equality comparer.
The node value to locate in the sequence.
true If the sequence contains an node that has the specified value; otherwise, false.
var seq = new YamlSequence(new YamlScalar("a"));
// different object that has same value
Assert.IsTrue(seq.Contains(new YamlScalar("a")));
// different value
Assert.IsFalse(s.Contains(str("b")));
Copies the child nodes of the to an , starting at a particular index.
The one-dimensional that is the destination of the elements copied from .
The zero-based index in at which copying begins.
is a null reference.
is less than 0.
array is multidimensional.
-or-
The number of elements in the source is greater than the available space from
to the end of the destination array.
Removes the first occurrence of a specific node from the .
The node to remove from the .
true if was successfully removed from the ; otherwise, false.
This method also returns false if is not found in the original .
Returns an enumerator that iterates through the all child nodes.
An enumerator that iterates through the all child nodes.
Gets or sets the node at the specified index.
The zero-based index of the node to get or set.
The node at the specified index.
is not a valid index in the ).
This property provides the ability to access a specific node in the sequence by using the following syntax: mySequence[index].
Gets the number of child nodes of the .
The number of child nodes of the sequence.
Implements utility functions to instantiating YamlNode's
var node_tree = seq(
str("abc"),
str("def"),
map(
str("key"), str("value"),
str("key2"), seq( str("value2a"), str("value2b") )
),
str("2"), // !!str
str("!!int", "2")
);
string yaml = node_tree.ToYaml();
// %YAML 1.2
// ---
// - abc
// - def
// - key: value
// key2: [ value2a, value2b ]
// - "2" # !!str
// - 2 # !!int
// ...
Create a scalar node. Tag is set to be "!!str".
var node_tree = seq(
str("abc"),
str("def"),
map(
str("key"), str("value"),
str("key2"), seq( str("value2a"), str("value2b") )
),
str("2"), // !!str
str("!!int", "2")
);
string yaml = node_tree.ToYaml();
// %YAML 1.2
// ---
// - abc
// - def
// - key: value
// key2: [ value2a, value2b ]
// - "2" # !!str
// - 2 # !!int
// ...
Value for the scalar node.
Created scalar node.
Create a scalar node.
Tag for the scalar node.
Value for the scalar node.
Created scalar node.
Create a sequence node. Tag is set to be "!!seq".
Child nodes.
Created sequence node.
Create a sequence node.
Child nodes.
Tag for the seuqnce.
Created sequence node.
Create a mapping node. Tag is set to be "!!map".
Sequential list of key/value pairs.
Created mapping node.
Create a mapping node.
Sequential list of key/value pairs.
Tag for the mapping.
Created mapping node.
object に代入されたクラスや構造体のメンバーに、リフレクションを
解して簡単にアクセスできるようにしたクラス
アクセス方法をキャッシュするので、繰り返し使用する場合に高速化が
期待できる
Caches ObjectMemberAccessor instances for reuse.
指定した型へのアクセス方法を表すインスタンスを返す
キャッシュに存在すればそれを返す
キャッシュに存在しなければ新しく作って返す
作った物はキャッシュされる
クラスまたは構造体を表す型情報
メンバ名と Accessor のペアを巡回する
メンバへの読み書きを行うことができる
オブジェクト
メンバの名前
Validates a text as a global tag in YAML.
RFC4151 - The 'tag' URI Scheme>
Base class to implement a parser class.
It allows not very efficient but easy implementation of a text parser along
with a parameterized BNF productions.
Parser specific state structure.
Parse the using the
as the starting rule.
Starting rule.
Text to be parsed.
Gets / sets source text to be parsed.
While parsing, this variable will not be changed.
The current position to be read by parser is represented by the field .
Namely, the next character to be read is text[p].
The current reading position.
The next character to be read by the parser is text[p].
Increase to reduce some part of source text .
The current position is automatically reverted at rewinding.
Example to show how to reduce BNF reduction rule of ( "t" "e" "x" "t" ).
return RewindUnless(()=>
text[p++] == 't' &&
text[p++] == 'e' &&
text[p++] == 'x' &&
text[p++] == 't'
);
Use this variable to build some string data from source text.
It will be automatically reverted at rewinding.
Individual-parser-specific state object.
It will be automatically reverted at rewinding.
If some action, in addition to simply restore the value of the state object,
is needed to recover the previous state, override
method.
Initialize , which represents line number to
start position of each line list.
Line number to start position list.
Reporting syntax error by throwing .
template for the error message.
parameters if required
Because it throw exception, nothing will be returned in reality.
Give warning if is true.
By default, the warning will not be shown / stored to anywhere.
To show or log the warning, override .
return
SomeObsoleteReductionRule() &&
WarningIf(
context != Context.IndeedObsolete,
"Obsolete");
If true, warning is given; otherwize do nothing.
template for the warning message.
parameters if required
Always true.
Give warning if is false.
By default, the warning will not be shown / stored to anywhere.
To show or log the warning, override .
return
SomeObsoleteReductionRule() &&
WarningUnless(
context != Context.NotObsolete,
"Obsolete");
If false, warning is given; otherwize do nothing.
template for the warning message.
parameters if required
Always true.
Give warning.
By default, the warning will not be shown / stored to anywhere.
To show or log the warning, override .
return
SomeObsoleteReductionRule() &&
Warning("Obsolete");
template for the warning message.
parameters if required
Always true.
Invoked when warning was given while parsing.
Override this method to display / store the warning.
Warning message.
Represents EBNF operator of "join", i.e. serial appearence of several rules.
This recoveres , ,
when does not return true.
If any specific operation is needed for rewinding, in addition to simply
recover the value of , override .
If false is returned, the parser status is rewound.
true if returned true; otherwise false.
name ::= first-name middle-name? last-name
bool Name()
{
return RewindUnless(()=>
FirstName() &&
Optional(MiddleName) &&
LastName()
);
}
This method is called just after recovers .
Override it to do any additional operation for rewinding.
Represents EBNF operator of "*".
Reduction rule to be repeated.
Always true.
lines-or-empty ::= line*
bool LinesOrEmpty()
{
return
Repeat(Line);
}
lines-or-empty ::= (text line-break)*
Note: Do not forget if several
rules are sequentially appears in operator.
bool LinesOrEmpty()
{
return
Repeat(()=>
RewindUnless(()=>
Text() &&
LineBreak()
)
);
}
Represents EBNF operator of "+".
Reduction rule to be repeated.
true if the rule matches; otherwise false.
lines ::= line+
bool Lines()
{
return
Repeat(Line);
}
lines ::= (text line-break)+
Note: Do not forget RewindUnless in Repeat operator.
bool Lines()
{
return
Repeat(()=>
RewindUnless(()=>
Text() &&
LineBreak()
)
);
}
Represents n times repeatition.
four-lines ::= (text line-break){4}
Note: Do not forget if several
rules are sequentially appears in operator.
bool FourLines()
{
return
Repeat(4, ()=>
RewindUnless(()=>
Text() &&
LineBreak()
)
);
}
Repetition count.
Reduction rule to be repeated.
true if the rule matches; otherwise false.
Represents at least , at most times repeatition.
google ::= "g" "o"{2,100} "g" "l" "e"
Note: Do not forget if several
rules are sequentially appears in operator.
bool Google()
{
return
RewindUnless(()=>
text[p++] == 'g' &&
Repeat(2, 100,
RewindUnless(()=>
text[p++] == 'o'
)
)
text[p++] == 'g' &&
text[p++] == 'l' &&
text[p++] == 'e'
);
}
Minimum repetition count. Negative value is treated as 0.
Maximum repetition count. Negative value is treated as positive infinity.
Reduction rule to be repeated.
true if the rule matches; otherwise false.
Represents BNF operator "?".
file ::= header? body footer?
Note: Do not forget if several
rules are sequentially appears in operator.
bool File()
{
return
Optional(Header()) &&
Body() &&
Optional(Footer());
}
Reduction rule that is optional.
Always true.
Represents BNF operator "?" (WITH rewinding wrap).
file = header? body footer?
Note: Do not forget if several
rules are sequentially appears in operator.
bool File()
{
return
Optional(Header) &&
Body() &&
Optional(Footer);
}
Reduction rule that is optional.
Always true.
Reduce one character if it is a member of the specified character set.
Acceptable character set.
true if the rule matches; otherwise false.
alpha ::= [A-Z][a-z]
num ::= [0-9]
alpha-num :: alpha | num
word ::= alpha ( alpha-num )*
Func<char,bool> Alpha = Charset( c =>
( 'A' <= c && c <= 'Z' ) ||
( 'a' <= c && c <= 'z' )
);
Func<char,bool> Num = Charset( c =>
'0' <= c && c <= '9'
);
Func<char,bool> AlphaNum = Charset( c =>
Alpha(c) || Num(c)
);
bool Word()
{
return
Accept(Alpha) &&
Repeat(AlphaNum);
// No need for RewindUnless
}
Accepts a character 'c'.
It can be also represented by text[p++] == c wrapped by .
The character to be accepted.
true if the rule matches; otherwise false.
YMCA ::= "Y" "M" "C" "A"
bool YMCA()
{
return
RewindUnless(()=>
Accept('Y') &&
Accept('M') &&
Accept('C') &&
Accept('A')
);
}
-or-
bool YMCA()
{
return
RewindUnless(()=>
text[p++] == 'Y' &&
text[p++] == 'M' &&
text[p++] == 'C' &&
text[p++] == 'A'
);
}
Accepts a sequence of characters.
Sequence of characters to be accepted.
true if the rule matches; otherwise false.
YMCA ::= "Y" "M" "C" "A"
bool YMCA()
{
return
Accept("YMCA");
}
Represents sequence of characters.
Sequence of characters to be accepted.
true if the rule matches; otherwise false.
Represents BNF operator of "*".
Character set to be accepted.
Always true.
Represents BNF operator of "+".
Character set to be accepted.
true if the rule matches; otherwise false.
Represents n times repetition of characters.
Character set to be accepted.
Repetition count.
true if the rule matches; otherwise false.
Represents at least min times, at most max times
repetition of characters.
Character set to be accepted.
Minimum repetition count. Negative value is treated as 0.
Maximum repetition count. Negative value is treated as positive infinity.
true if the rule matches; otherwise false.
Represents BNF operator "?".
Character set to be accepted.
Always true.
Builds a performance-optimized table-based character set definition from a simple
but slow comparison-based definition.
By default, the character table size is 0x100, namely only the characters of [\0-\xff] are
judged by using a character table and others are by the as-given slow comparisn-based definitions.
To have maximized performance, locate the comparison for non-table based judgement first
in the definition as the example below.
Use form to explicitly
specify the table size.
This sample shows how to build a character set delegate.
static class YamlCharsets: Charsets
{
Func<char, bool> cPrintable;
Func<char, bool> sWhite;
static YamlCharsets()
{
cPrintable = CacheResult(c =>
/* ( 0x10000 < c && c < 0x110000 ) || */
( 0xe000 <= c && c <= 0xfffd ) ||
( 0xa0 <= c && c <= 0xd7ff ) ||
( c < 0x100 && ( // to improve performance
c == 0x85 ||
( 0x20 <= c && c <= 0x7e ) ||
c == 0x0d ||
c == 0x0a ||
c == 0x09
) )
);
sWhite = CacheResult(c =>
c < 0x100 && ( // to improve performance
c == '\t' ||
c == ' '
)
);
}
}
A simple but slow comparison-based definition of the charsert.
A performance-optimized table-based delegate built from the given .
Builds a performance-optimized table-based character set definition from a simple
but slow comparison-based definition.
Characters out of the table are judged by the as-given slow comparisn-based
definitions.
So, to have maximized performance, locate the comparison for non-table based
judgement first in the definition as the example below.
This sample shows how to build a character set delegate.
static class YamlCharsets: Charsets
{
Func<char, bool> cPrintable;
Func<char, bool> sWhite;
static YamlCharsets()
{
cPrintable = CacheResult(c =>
/* ( 0x10000 < c && c < 0x110000 ) || */
( 0xe000 <= c && c <= 0xfffd ) ||
( 0xa0 <= c && c <= 0xd7ff ) ||
( c < 0x100 && ( // to improve performance
c == 0x85 ||
( 0x20 <= c && c <= 0x7e ) ||
c == 0x0d ||
c == 0x0a ||
c == 0x09
) )
);
sWhite = CacheResult(c =>
c < 0x100 && ( // to improve performance
c == '\t' ||
c == ' '
)
);
}
}
Character table size.
A simple but slow comparison-based definition of the charsert.
A performance-optimized table-based delegate built from the given .
Saves a part of the source text that is reduced in the .
If the rule does not match, nothing happends.
Reduction rule to match.
If the matches,
the part of the source text reduced in the is set;
otherwise String.Empty is set.
true if matches; otherwise false.
Saves a part of the source text that is reduced in the
and append it to .
If the rule does not match, nothing happends.
Reduction rule to match.
true if matches; otherwise false.
Saves a part of the source text that is reduced in the .
If the rule does not match, nothing happends.
Reduction rule to match.
If matches, this delegate is invoked
with the part of the source text that is reduced in the
as the parameter. Do any action in the delegate.
true if matches; otherwise false.
bool SomeRule()
{
return
Save(()=> SubRule(), s => MessageBox.Show(s));
}
Execute some action.
Action to be done.
Always true.
bool SomeRule()
{
return
SubRule() &&
Action(()=> do_some_action());
}
Report error by throwing when the does not match.
Some reduction rule that must match.
Error message as template
Parameters for template
Always true; otherwise an exception thrown.
Report error by throwing when the does not match.
Some reduction rule that must match.
Error message as template
Parameters for template
Always true; otherwise an exception is thrown.
Report error by throwing when the does not match
and an additional condition is true.
Some reduction rule that must match.
Additional condition: if this parameter is false,
rewinding occurs, instead of throwing exception.
Error message as template
Parameters for template
true if the reduction rule matches; otherwise false.
Report error by throwing when is true.
True to throw exception.
Error message as template
Parameters for template
Always true.
Assign var = value and return true;
Type of the variable and value.
Variable to be assigned.
Value to be assigned.
Always true.
Get current position represented by raw and column.
Represents a position in a multiline text.
Raw in a text.
Column in a text.
Validates a text as a global tag in YAML.
A candidate for a global tag in YAML.
True if is a valid global tag.
Not used in this parser
Reset();
SetupDefaultTagPrefixes();
Add(tag_handle, tag_prefix);
verbatim_tag = Resolve(tag_handle, tag_name);
class has instance methods and ,
with which C# native objects can be converted into / from YAML text without any preparations.
var serializer = new YamlSerializer();
object obj = GetObjectToSerialize();
string yaml = serializer.Serialize(obj);
object restored = serializer.Deserialize(yaml);
Assert.AreEqual(obj, restored);
What kind of objects can be serialized?
can serialize / deserialize native C# objects of primitive types
(bool, char, int,...), enums, built-in non-primitive types (string, decimal), structures,
classes and arrays of these types.
On the other hand, it does not deal with IntPtr (which is a primitive type, though) and
pointer types (void*, int*, ...) because these types are, by their nature, not persistent.
Classes without a default constructor can be deserialized only when the way of activating an instance
is explicitly specified by .
object obj = new object[]{
null,
"abc",
true,
1,
(Byte)1,
1.0,
"1",
new double[]{ 1.1, 2, -3 },
new string[]{ "def", "ghi", "1" },
new System.Drawing.Point(1,3),
new System.Drawing.SolidBrush(Color.Blue)
};
var serializer = new YamlSerializer();
string yaml = serializer.Serialize(obj);
// %YAML 1.2
// ---
// - null
// - abc
// - True
// - 1
// - !System.Byte 1
// - !!float 1
// - "1"
// - !<!System.Double[]%gt; [1.1, 2, -3]
// - !<!System.String[]%gt;
// - def
// - ghi
// - !System.Drawing.Point 1, 3
// - !System.Drawing.SolidBrush
// Color: Blue
// ...
object restored;
try {
restored = YamlSerializer.Deserialize(yaml)[0];
} catch(MissingMethodException) {
// default constructor is missing for SolidBrush
}
// Let the library know how to activate an instance of SolidBrush.
YamlNode.DefaultConfig.AddActivator<System.Drawing.SolidBrush>(
() => new System.Drawing.SolidBrush(Color.Black /* dummy */));
// Then, all the objects can be restored correctly.
restored = serializer.Deserialize(yaml)[0];
A YAML document generated by always have a %YAML directive and
explicit document start ("---") and end ("...") marks.
This allows several documents to be written in a single YAML stream.
var yaml = "";
var serializer = new YamlSerializer();
yaml += serializer.Serialize("a");
yaml += serializer.Serialize(1);
yaml += serializer.Serialize(1.1);
// %YAML 1.2
// ---
// a
// ...
// %YAML 1.2
// ---
// 1
// ...
// %YAML 1.2
// ---
// 1.1
// ...
object[] objects = serializer.Deserialize(yaml);
// objects[0] == "a"
// objects[1] == 1
// objects[2] == 1.1
Since a YAML stream can consist of multiple YAML documents as above,
returns an array of .
Serializing structures and classes
For structures and classes, by default, all public fields and public properties are
serialized. Note that protected / private members are always ignored.
Serialization methods
Readonly value-type members are also ignored because there is no way to
assign a new value to them on deserialization, while readonly class-type members
are serialized. When deserializing, instead of creating a new object and assigning it
to the member, the child members of such class instance are restored independently.
Such a deserializing method is refered to
YamlSerializeMethod.Content.
On the other hand, when writeable fields/properties are deserialized, new objects are
created by using the parameters in the YAML description and assiend to the fields/properties.
Such a deserializing method is refered to
YamlSerializeMethod.Assign. Writeable properties can be explicitly specified to use
YamlSerializeMethod.Content method for
deserialization, by adding to its definition.
Another type of serializing method is
YamlSerializeMethod.Binary.
This method is only applicable to an array-type field / property that contains
only value-type members.
If serializing method is specified,
the member is never serialized nor deserialized.
public class Test1
{
public int PublicProp { get; set; } // processed (by assign)
protected int ProtectedProp { get; set; } // Ignored
private int PrivateProp { get; set; } // Ignored
internal int InternalProp { get; set; } // Ignored
public int PublicField; // processed (by assign)
protected int ProtectedField; // Ignored
private int PrivateField; // Ignored
internal int InternalField; // Ignored
public List<string> ClassPropByAssign // processed (by assign)
{ get; set; }
public int ReadOnlyValueProp { get; private set; } // Ignored
public List<string> ReadOnlyClassProp // processed (by content)
{ get; private set; }
[YamlSerialize(YamlSerializeMethod.Content)]
public List<string> ClassPropByContent// processed (by content)
{ get; set; }
public int[] IntArrayField = // processed (by assign)
new int[10];
[YamlSerialize(YamlSerializeMethod.Binary)]
public int[] IntArrayFieldBinary = // processed (as binary)
new int[100];
[YamlSerialize(YamlSerializeMethod.Never)]
public int PublicPropHidden; // Ignored
public Test1()
{
ClassPropByAssign = new List<string>();
ReadOnlyClassProp = new List<string>();
ClassPropByContent = new List<string>();
}
}
public void TestPropertiesAndFields1()
{
var test1 = new Test1();
test1.ClassPropByAssign.Add("abc");
test1.ReadOnlyClassProp.Add("def");
test1.ClassPropByContent.Add("ghi");
var rand = new Random(0);
for ( int i = 0; i < test1.IntArrayFieldBinary.Length; i++ )
test1.IntArrayFieldBinary[i] = rand.Next();
var serializer = new YamlSerializer();
string yaml = serializer.Serialize(test1);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test1
// PublicProp: 0
// ClassPropByAssign:
// Capacity: 4
// ICollection.Items:
// - abc
// ReadOnlyClassProp:
// Capacity: 4
// ICollection.Items:
// - def
// ClassPropByContent:
// Capacity: 4
// ICollection.Items:
// - ghi
// PublicField: 0
// IntArrayField: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// IntArrayFieldBinary: |+2
// Gor1XAwenmhGkU5ib9NxR11LXxp1iYlH5LH4c9hImTitWSB9Z78II2UvXSXV99A79fj6UBn3GDzbIbd9
// yBDjAyslYm58iGd/NN+tVjuLRCg3cJBo+PWMbIWm9n4AEC0E7LKXWV5HXUNk7I13APEDWFMM/kWTz2EK
// s7LzFw2gBjpKugkmQJqIfinpQ1J1yqhhz/XjA3TBxDBsEuwrD+SNevQSqEC+/KRbwgE6D011ACMeyRt0
// BOG6ZesRKCtL0YU6tSnLEpgKVBz+R300qD3/W0aZVk+1vHU+auzyGCGUaHCGd6dpRoEhXoIg2m3+AwJX
// EJ37T+TA9BuEPJtyGoq+crQMFQtXj1Zriz3HFbReclLvDdVpZlcOHPga/3+3Y509EHZ7UyT7H1xGeJxn
// eXPrDDb0Ul04MfZb4UYREOfR3HNzNTUYGRsIPUvHOEW7AaoplIfkVQp19DvGBrBqlP2TZ9atlWUHVdth
// 7lIBeIh0wiXxoOpCbQ7qVP9GkioQUrMkOcAJaad3exyZaOsXxznFCA==
// ...
}
Default values of fields and properties
is aware of
System.ComponentModel.DefaultValueAttribute.
So, when a member of a structure / class instance has a value that equals to the default value,
the member will not be written in the YAML text.
It also checkes for the result of ShouldSerializeXXX method. For instance, just before serializing Font
property of some type, bool ShouldSerializeFont() method is called if exists. If the method returns false,
Font property will not be written in the YAML text. ShouldSerializeXXX method can be non-public.
using System.ComponentModel;
public class Test2
{
[DefaultValue(0)]
public int Default0 = 0;
[DefaultValue("a")]
public string Defaulta = "a";
public int DynamicDefault = 0;
bool ShouldSerializeDynamicDefault()
{
return Default0 != DynamicDefault;
}
}
public void TestDefaultValue()
{
var test2 = new Test2();
var serializer = new YamlSerializer();
// All properties have defalut values.
var yaml = serializer.Serialize(test2);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test2 {}
// ...
test2.Defaulta = "b";
yaml = serializer.Serialize(test2);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test2
// Defaulta: b
// ...
test2.Defaulta = "a";
var yaml = serializer.Serialize(test2);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test2 {}
// ...
test2.DynamicDefault = 1;
yaml = serializer.Serialize(test2);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test2
// DynamicDefault: 1
// ...
test2.Default0 = 1;
yaml = serializer.Serialize(test2);
// %YAML 1.2
// ---
// !YamlSerializerTest.Test2
// Default0: 1
// ...
}
Collection classes
If an object implements , or
the child objects are serialized as well its other public members.
Pseudproperty ICollection.Items or IDictionary.Entries appears to hold the child objects.
Multitime appearance of a same object
preserve C# objects' graph structure. Namely, when a same objects are refered to
from several points in the object graph, the structure is correctly described in YAML text and restored objects
preserve the structure. can safely manipulate directly / indirectly self refering
objects, too.
public class TestClass
{
public List<TestClass> list =
new List<TestClass>();
}
public class ChildClass: TestClass
{
}
void RecursiveObjectsTest()
{
var a = new TestClass();
var b = new ChildClass();
a.list.Add(a);
a.list.Add(a);
a.list.Add(b);
a.list.Add(a);
a.list.Add(b);
b.list.Add(a);
var serializer = new YamlSerializer();
string yaml = serializer.Serialize(a);
// %YAML 1.2
// ---
// &A !TestClass
// list:
// Capacity: 8
// ICollection.Items:
// - *A
// - *A
// - &B !ChildClass
// list:
// Capacity: 4
// ICollection.Items:
// - *A
// - *A
// - *B
// ...
var restored = (TestClass)serializer.Deserialize(yaml)[0];
Assert.IsTrue(restored == restored.list[0]);
Assert.IsTrue(restored == restored.list[1]);
Assert.IsTrue(restored == restored.list[3]);
Assert.IsTrue(restored == restored.list[5]);
Assert.IsTrue(restored.list[2] == restored.list[4]);
}
This is not the case if the object is . Same instances of
are repeatedly written in a YAML text and restored as different
instance of when deserialized, unless the content of the string
is extremely long (longer than 999 chars).
// 1000 chars
string long_str =
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" +
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
string short_str = "12345";
object obj = new object[] { long_str, long_str, short_str, short_str };
var serializer = new YamlSerializer();
string yaml = serializer.Serialize(obj);
// %YAML 1.2
// ---
// - &A 01234567890123456789012345678901234567890123456789 ... (snip) ... 789
// - *A
// - "12345"
// - "12345"
// ...
YAML text written / read by
When serializing, intelligently uses various YAML 1.2 styles,
namely the block style, flow style, explicit mapping and implicit mapping, to maximize readability
of the YAML stream.
[Flags]
enum TestEnum: uint
{
abc = 1,
あいう = 2
}
public void TestVariousFormats()
{
var dict = new Dictionary<object, object>();
dict.Add(new object[] { 1, "a" }, new object());
object obj = new object[]{
dict,
null,
"abc",
"1",
"a ",
"- a",
"abc\n",
"abc\ndef\n",
"abc\ndef\nghi",
new double[]{ 1.1, 2, -3, 3.12, 13.2 },
new int[,] { { 1, 3}, {4, 5}, {10, 1} },
new string[]{ "jkl", "mno\npqr" },
new System.Drawing.Point(1,3),
TestEnum.abc,
TestEnum.abc | TestEnum.あいう,
};
var config = new YamlConfig();
config.ExplicitlyPreserveLineBreaks = false;
var serializer = new YamlSerializer(config);
string yaml = serializer.Serialize(obj);
// %YAML 1.2
// ---
// - !<!System.Collections.Generic.Dictionary%602[[System.Object,...],[System.Object,...]]>
// Keys: {}
// Values: {}
// IDictionary.Entries:
// ? - 1
// - a
// : !System.Object {}
// - null
// - abc
// - "1"
// - "a "
// - "- a"
// - "abc\n"
// - |+2
// abc
// def
// - |-2
// abc
// def
// ghi
// - !<!System.Double[]> [1.1, 2, -3, 3.12, 13.2]
// - !<!System.Int32[,]> [[1, 3], [4, 5], [10, 1]]
// - !<!System.String[]>
// - jkl
// - |-2
// mno
// pqr
// - !System.Drawing.Point 1, 3
// - !TestEnum abc
// - !TestEnum abc, あいう
// ...
}
When deserializing, accepts any valid YAML 1.2 documents.
TAG directives, comments, flow / block styles, implicit / explicit mappings can be freely used
to express valid C# objects. Namely, the members of the array can be given eighter in a flow style
or in a block style.
By default, outputs a YAML stream with line break of "\r\n".
This can be customized either by setting YamlNode.DefaultConfig.LineBreakForOutput or
by giving an instance of to the
constructor.
var serializer = new YamlSerializer();
var yaml = serializer.Serialize("abc");
// %YAML 1.2\r\n // line breaks are explicitly shown in this example
// ---\r\n
// abc\r\n
// ...\r\n
var config = new YamlConfig();
config.LineBreakForOutput = "\n";
serializer = new YamlSerializer(config);
var yaml = serializer.Serialize("abc");
// %YAML 1.2\n
// ---\n
// abc\n
// ...\n
YamlNode.DefaultConfig.LineBreakForOutput = "\n";
var serializer = new YamlSerializer();
serializer = new YamlSerializer();
var yaml = serializer.Serialize("abc");
// %YAML 1.2\n
// ---\n
// abc\n
// ...\n
Line breaks in YAML text
By default, line breaks in multi line values are explicitly presented as escaped style.
Although, this makes the resulting YAML stream hard to read, it is necessary to preserve
the exact content of the string because the YAML specification requires that a YAML parser
must normalize evely line break that is not escaped in a YAML document to be a single line
feed "\n" when deserializing.
In order to have the YAML documents easy to be read, set
YamlConfig.ExplicitlyPreserveLineBreaks
false. Then, the multiline values of will be written in literal style.
Of course, it makes all the line breaks to be normalized into a single line feeds "\n".
var serializer = new YamlSerializer();
var text = "abc\r\n def\r\nghi\r\n";
// abc
// def
// ghi
// By default, line breaks explicitly appears in escaped form.
var yaml = serializer.Serialize(text);
// %YAML 1.2
// ---
// "abc\r\n\
// \ def\r\n\
// ghi\r\n"
// ...
// Original line breaks are preserved
var restored = (string)serializer.Deserialize(yaml)[0];
// "abc\r\n def\r\nghi\r\n"
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
// Literal style is easier to be read.
var yaml = serializer.Serialize(text);
// %YAML 1.2
// ---
// |+2
// abc
// def
// ghi
// ...
// Original line breaks are lost.
var restored = (string)serializer.Deserialize(yaml)[0];
// "abc\n def\nghi\n"
This library offers two work arounds for this problem, although both of which
violates the official behavior of a YAML parser defined in the YAML specification.
One is to set YamlConfig.LineBreakForInput
to be "\r\n". Then, the YAML parser normalizes all line breaks into "\r\n" instead of "\n".
The other is to set YamlConfig.NormalizeLineBreaks
false. It disables the line break normalization both at output and at input. Namely, the line breaks are
written and read as-is when serialized / deserialized.
var serializer = new YamlSerializer();
// text with mixed line breaks
var text = "abc\r def\nghi\r\n";
// abc\r // line breaks are explicitly shown in this example
// def\n
// ghi\r\n
YamlNode.DefaultConfig.ExplicitlyPreserveLineBreaks = false;
// By default, all line breaks are normalized to "\r\n" when serialized.
var yaml = serializer.Serialize(text);
// %YAML 1.2\r\n
// ---\r\n
// |+2\r\n
// abc\r\n
// def\r\n
// ghi\r\n
// ...\r\n
// When deserialized, line breaks are normalized into "\n".
var restored = (string)serializer.Deserialize(yaml)[0];
// "abc\n def\nghi\n"
// Line breaks are normalized into "\r\n" instead of "\n".
YamlNode.DefaultConfig.LineBreakForInput = "\r\n";
restored = (string)serializer.Deserialize(yaml)[0];
// "abc\r\n def\r\nghi\r\n"
// Line breaks are written as is,
YamlNode.DefaultConfig.NormalizeLineBreaks = false;
var yaml = serializer.Serialize(text);
// %YAML 1.2\r\n
// ---\r\n
// |+2\r\n
// abc\r
// def\n
// ghi\r\n
// ...\r\n
// and are read as is.
restored = (string)serializer.Deserialize(yaml)[0];
// "abc\r def\nghi\r\n"
// Note that when the line breaks of YAML stream is changed
// between serialization and deserialization, the original
// line breaks are lost.
yaml = yaml.Replace("\r\n", "\n").Replace("\r", "\n");
restored = (string)serializer.Deserialize(yaml)[0];
// "abc\n def\nghi\n"
It is repeatedly stated that although these two options are useful in many situation,
they makes the YAML parser violate the YAML specification.
Initialize an instance of that obeys
.
Initialize an instance of with custom .
Custom to customize serialization.
Serialize C# object into YAML text.
Object to be serialized.
YAML text.
Serialize C# object into YAML text and write it into a .
A to which the YAML text is written.
Object to be serialized.
Serialize C# object into YAML text and write it into a .
A to which the YAML text is written.
Object to be serialized.
Serialize C# object into YAML text and save it into a file named as .
A file name to which the YAML text is written.
Object to be serialized.
Deserialize C# object(s) from a YAML text. Since a YAML text can contain multiple YAML documents, each of which
represents a C# object, the result is returned as an array of .
A YAML text from which C# objects are deserialized.
Expected type(s) of the root object(s) in the YAML stream.
C# object(s) deserialized from YAML text.
Deserialize C# object(s) from a YAML text in a .
Since a YAML text can contain multiple YAML documents, each of which
represents a C# object, the result is returned as an array of .
A that contains YAML text from which C# objects are deserialized.
Expected type(s) of the root object(s) in the YAML stream.
C# object(s) deserialized from YAML text.
Deserialize C# object(s) from a YAML text in a .
Since a YAML text can contain multiple YAML documents, each of which
represents a C# object, the result is returned as an array of .
A that contains YAML text from which C# objects are deserialized.
Expected type(s) of the root object(s) in the YAML stream.
C# object(s) deserialized from YAML text.
Deserialize C# object(s) from a YAML text in a file named as .
Since a YAML text can contain multiple YAML documents, each of which
represents a C# object, the result is returned as an array of .
The name of a file that contains YAML text from which C# objects are deserialized.
Expected type(s) of the root object(s) in the YAML stream.
C# object(s) deserialized from YAML text.
Add .DoFunction method to string
Short expression of string.Format(XXX, arg1, arg2, ...)
Specify the way to store a property or field of some class or structure.
See for detail.
The property / field will not be stored.
When restored, new object is created by using the parameters in
the YAML data and assigned to the property / field. When the
property / filed is writeable, this is the default.
Only valid for a property / field that has a class or struct type.
When restored, instead of recreating the whole class or struct,
the members are independently restored. When the property / field
is not writeable this is the default.
Only valid for a property / field that has an array type of a
some value type. The content of the array is stored in a binary
format encoded in base64 style.
Specify the way to store a property or field of some class or structure.
See for detail.
Specify the way to store a property or field of some class or structure.
See for detail.
- Never: The property / field will not be stored.
- Assign: When restored, new object is created by using the parameters in
the YAML data and assigned to the property / field. When the
property / filed is writeable, this is the default.
- Content: Only valid for a property / field that has a class or struct type.
When restored, instead of recreating the whole class or struct,
the members are independently restored. When the property / field
is not writeable this is the default.
- Binary: Only valid for a property / field that has an array type of a
some value type. The content of the array is stored in a binary
format encoded in base64 style.
Represents the way to automatically resolve Tag from the Value of a YamlScalar.
Create TagResolver with default resolution rules.
Add default tag resolution rules to the rule list.
List of tag resolution rules.
Add a tag resolution rule that is invoked when matches
the Value of a node.
The tag is resolved to and is
invoked when actual value of type is extracted from
the node text.
Surround sequential calls of this function by /
pair to avoid invoking slow internal calculation method many times.
BeginUpdate(); // to avoid invoking slow internal calculation method many times.
Add( ... );
Add( ... );
Add( ... );
Add( ... );
EndUpdate(); // automaticall invoke internal calculation method
Supress invoking slow internal calculation method when
called.
BeginUpdate / can be called nestedly.
Quit to supress invoking slow internal calculation method when
called.
Execute tag resolution and returns automatically determined tag value from .
Node text with which automatic tag resolution is done.
Automatically determined tag value .
Decode and returns actual value in C# object.
Node to be decoded.
Decoded value.
True if decoded successfully.
Extend string object to have .DoubleQuoteEscape() / .DoubleQuoteUnescape().
Escape control codes with YAML double quoted string format.
Unescape control codes escaped with YAML double quoted string format.
YAML style double quoted string escape / unescape.
Initialize tables
Escape control codes, double quotations, backslashes in the YAML double quoted string format
Unescape control codes, double quotations, backslashes escape in the YAML double quoted string format
Type 関連のユーティリティメソッド
Type type;
AttributeType attr = type.GetAttribute<AttributeType>();
PropertyInfo propInfo;
AttributeType attr = propInfo.GetAttribute<AttributeType>();
string name;
Type type = TypeUtils.GetType(name); // search from all assembly loaded
Type や PropertyInfo, FieldInfo から指定された型の属性を取り出して返す
複数存在した場合には最後の値を返す
存在しなければ null を返す
取り出したい属性の型
取り出した属性値
現在ロードされているすべてのアセンブリから name という名の型を探して返す
Check if the type is a ValueType and does not contain any non ValueType members.
Returnes true if the specified is a struct type.
to be analyzed.
true if the specified is a struct type; otehrwise false.
Compare two objects to see if they are equal or not. Null is acceptable.
Return if an object is a numeric value.
Any object to be tested.
True if object is a numeric value.
Cast an object to a specified numeric type.
Any object
Numric type
Numeric value or null if the object is not a numeric value.
Cast boxed numeric value to double
boxed numeric value
Numeric value in double. Double.Nan if obj is not a numeric value.
Check if type is fully public or not.
Nested class is checked if all declared types are public.
Equality comparer that uses Object.ReferenceEquals(x, y) to compare class values.
Determines whether two objects of type T are equal by calling Object.ReferenceEquals(x, y).
The first object to compare.
The second object to compare.
true if the specified objects are equal; otherwise, false.
Serves as a hash function for the specified object for hashing algorithms and
data structures, such as a hash table.
The object for which to get a hash code.
A hash code for the specified object.
is null.
Returns a default equality comparer for the type specified by the generic argument.
The default instance of the System.Collections.Generic.EqualityComparer<T>
class for type T.
Calculate hash code by reference.
Initializes a new instance of the HashCodeByRef<T> class.
Calculate hash code by reference.
A text parser for
YAML Ain’t Markup Language (YAML™) Version 1.2
3rd Edition (2009-07-21)
http://yaml.org/spec/1.2/spec.html
This class parse a YAML document and compose representing graph.
string yaml = LoadYamlSource();
YamlParser parser = new YamlParser();
Node[] result = null;
try {
result = parser.Parse(yaml);
...
// you can reuse parser as many times you want
...
} catch( ParseErrorException e ) {
MessageBox.Show(e.Message);
}
if(result != null) {
...
}
Currently, this parser violates the YAML 1.2 specification in the following points.
- line breaks are not normalized.
- omission of the final line break is allowed in plain / literal / folded text.
- ':' followed by ns-indicator is excluded from ns-plain-char.
Initialize a YAML parser.
Parse YAML text and returns a list of .
YAML text to be parsed.
A list of parsed from the given text
Parse YAML text and returns a list of .
YAML text to be parsed.
YAML Configuration to be used in parsing.
A list of parsed from the given text
Add message in property.
Invoked when unknown directive is found in YAML document.
Name of the directive
Parameters for the directive
Invoked when YAML directive is found in YAML document.
Given version
rewinding action
set status.tag with tag resolution
set status.tag with verbatim tag value
verbatim tag
Used when the parser resolves a tag for a scalar node from its value.
New resolution rules can be add before calling method.
[105]
[106]
Warnings that are made while parsing a YAML text.
This property is cleared by new call for method.
additional fields to be rewound
tag for the next value (will be cleared when the next value is created)
anchor for the next value (will be cleared when the next value is created)
current value
anchor rewinding position
[22]
[23]
Add string class two methods: .UriEscape(), .UriUnescape()
Charset that is not escaped is represented NonUriChar member.
NonUriChar = new Regex(@"[^0-9A-Za-z\-_.!~*'()\\;/?:@&=$,\[\]]");
Escape the string in URI encoding format.
String to be escaped.
Escaped string.
Escape the string in URI encoding format.
String to be escaped.
Escaped string.
Unescape the string escaped in URI encoding format.
String to be unescape.
Unescaped string.
Escape / Unescape string in URI encoding format
Charset that is not escaped is represented NonUriChar member.
NonUriChar = new Regex(@"[^0-9A-Za-z\-_.!~*'()\\;/?:@&=$,\[\]]");
When reports syntax error by exception, this class is thrown.
Sytax errors can also be reported by simply returing false with giving some warnings.
Initialize an instance of
Error message.
Converts C# object to YamlNode
object obj;
YamlNode node = YamlRepresenter.ObjectToNode(obj);
Dictionary that automatically rehash when the content of a key is changed.
Keys of this dictionary must implement .
It also call back item addition and removal by and
events.
Type of key. Must implements .
Type of value.
A dictionary that returns or
from hash code. This is the main repository that stores the pairs.
If there are several entries that have same hash code for thir keys,
a is stored to hold all those entries.
Otherwise, a is stored.
A dictionary that returns hash code from the key reference.
The key must be the instance that
to one exsisting in the dictionary.
We store the hashes correspoinding to each key. So that when rehash,
we can find old hash code to quickly find the entry for the key.
It is also used to remember the number of keys exists in the dictionary.
Recalc hash key of the .
The key to be rehash. The key must be the instance that
to one exsisting in the dictionary.
Try to find entry for key (and value).
key to find
if true, value matters
value to find
key not found
hash hit one entry and key found
hash hit several entries and key found
Try to find entry for key (and value).
key to find
if true, value matters
value to find
hash not found
hash hit one entry but key not found
hash hit one entry and key found
hash hit several entries but key not found
hash hit several entries and key found
Collection that is readonly and invalidated when an item is
added to or removed from the dictionary.
Converts YamlNode tree into yaml text.
YamlNode node;
YamlPresenter.ToYaml(node);
YamlNode node1;
YamlNode node2;
YamlNode node3;
YamlPresenter.ToYaml(node1, node2, node3);
Converts various types to / from string.
I don't remember why this class was needed....
object obj = GetObjectToConvert();
// Check if the type has [TypeConverter] attribute.
if( EasyTypeConverter.IsTypeConverterSpecified(type) ) {
// Convert the object to string.
string s = EasyTypeConverter.ConvertToString(obj);
// Convert the string to an object of the spific type.
object restored = EasyTypeConverter.ConvertFromString(s, type);
Assert.AreEqual(obj, restored);
}
Construct YAML node tree that represents a given C# object.
Construct YAML node tree that represents a given C# object.
to be converted to C# object.
to customize serialization.
Construct YAML node tree that represents a given C# object.
to be converted to C# object.
Expected type for the root object.
to customize serialization.