/// <summary>
/// Returns the C# literal representation of a given primitive expression.
/// (Useful for escaping strings)
/// </summary>
private static string PrimitiveLiteral(this string input)
{
var writer = new StringWriter();
var provider = new CSharpCodeProvider();
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
return writer.ToString();
}
/// <summary>
/// Converts a string to a C sharp string literal.
/// </summary>
public static string ToLiteral(this string input)
{
var writer = new StringWriter();
CSharpCodeProvider provider = new CSharpCodeProvider();
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
return writer.GetStringBuilder().ToString();
}
public static string ToString(object value)
{
var text = new StringBuilder();
using (var provider = new CSharpCodeProvider())
{
using (var writer = new StringWriter(text, CultureInfo.InvariantCulture))
{
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(value), writer, DefaultCodeGeneratorOptions);
}
}
return text.ToString();
}
public static string GenerateCode(CodeObject codeObj)
{
var provider = new CSharpCodeProvider();
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
if (codeObj is CodeCompileUnit)
{
provider.GenerateCodeFromCompileUnit(codeObj as CodeCompileUnit, writer, null);
}
else if (codeObj is CodeExpression)
{
provider.GenerateCodeFromExpression(codeObj as CodeExpression, writer, null);
}
else if (codeObj is CodeStatement)
{
provider.GenerateCodeFromStatement(codeObj as CodeStatement, writer, null);
}
else if (codeObj is CodeTypeMember)
{
provider.GenerateCodeFromMember(codeObj as CodeTypeMember, writer, null);
}
else if (codeObj is CodeNamespace)
{
provider.GenerateCodeFromNamespace(codeObj as CodeNamespace, writer, null);
}
else
{
throw new InvalidOperationException();
}
writer.Flush();
stream.Position = 0;
using (var reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
}
}
// http://stackoverflow.com/a/1363212/1060807
public static string TypeToString(Type type)
{
if (type == null) throw new ArgumentNullException("type");
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var expr = new CodeTypeReferenceExpression(type);
var prov = new CSharpCodeProvider();
prov.GenerateCodeFromExpression(expr, sw, new CodeGeneratorOptions());
}
return sb.ToString();
}
private static string FormatArgument(object arg)
{
using(StringWriter sw = new StringWriter())
{
CSharpCodeProvider provider = new CSharpCodeProvider();
provider.GenerateCodeFromExpression(new CodePrimitiveExpression(arg), sw, null);
return sw.ToString();
}
}
/// <summary>
/// Generates CSharp text from a expression and writes it to a text writer with the given options.
/// </summary>
/// <param name="expression">The expressoin to generate text from.</param>
/// <param name="writer">The text writer to write to.</param>
/// <param name="options">The generation options.</param>
public static void GenerateCSharpTo(this CodeExpression expression, TextWriter writer, CodeGeneratorOptions options)
{
using (var provider = new CSharpCodeProvider())
{
provider.GenerateCodeFromExpression(expression, writer, options);
}
}
/// <summary>
/// Generates full literal representation of a string
/// </summary>
/// <param name="input">The string input, like "hello,\t\".NET\""</param>
/// <returns>The full literal of the string, like "\"hello,\\t\\\".NET\\\"\""</returns>
public static string ToLiteral(string input)
{
var writer = new StringWriter();
var codeGen = new CSharpCodeProvider();
codeGen.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
return writer.ToString();
}
public string CreateLiteral(object value)
{
if (value == null)
{
return string.Empty;
}
Type type = value.GetType();
if (type.IsEnum)
{
return type.FullName + "." + value.ToString();
}
if (type == typeof(Guid))
{
return string.Format(CultureInfo.InvariantCulture, "new Guid(\"{0}\")",
((Guid)value).ToString("D", CultureInfo.InvariantCulture));
}
else if (type == typeof(DateTime))
{
return string.Format(CultureInfo.InvariantCulture, "new DateTime({0}, DateTimeKind.Unspecified)",
((DateTime)value).Ticks);
}
else if (type == typeof(byte[]))
{
var arrayInit = string.Join(", ", ((byte[])value).Select(b => b.ToString(CultureInfo.InvariantCulture)).ToArray());
return string.Format(CultureInfo.InvariantCulture, "new Byte[] {{{0}}}", arrayInit);
}
else if (type == typeof(DateTimeOffset))
{
var dto = (DateTimeOffset)value;
return string.Format(CultureInfo.InvariantCulture, "new DateTimeOffset({0}, new TimeSpan({1}))",
dto.Ticks, dto.Offset.Ticks);
}
var expression = new CodePrimitiveExpression(value);
var writer = new StringWriter();
CSharpCodeProvider code = new CSharpCodeProvider();
code.GenerateCodeFromExpression(expression, writer, new CodeGeneratorOptions());
return writer.ToString();
}
private string GenerateCodeFromExpression(CodeExpression expression)
{
string code = string.Empty;
using (CSharpCodeProvider csc = new CSharpCodeProvider())
using (StringWriter sw = new StringWriter())
{
csc.GenerateCodeFromExpression(expression, sw, new CodeGeneratorOptions());
code = sw.ToString();
}
return code;
}
protected string SerializeValue(object value)
{
if (value == null)
{
// code generation for null - nothing fancy here
return "null";
}
var type = value.GetType();
if (this.typeSerializers.ContainsKey(type.FullName))
{
// code generation by custom handler
return this.typeSerializers[type.FullName](value);
}
else
{
try
{
if (value is Enum)
{
// code generation for enums
return type.FullName + "." + Enum.GetName(type, value);
}
else
{
// code generation using codedom - works for most simple types
var w = new StringWriter();
var e = new CodePrimitiveExpression(value);
var o = new CodeGeneratorOptions();
var p = new CSharpCodeProvider();
p.GenerateCodeFromExpression(e, w, o);
return w.ToString();
}
}
catch (ArgumentException ex)
{
throw new NotImplementedException("Cannot serialize value of type " + type.Name + ".", ex);
}
}
}
