public DefinitionsTests()
{
var simpleTypeChecker = new SimpleTypeHelper();
var complexTypeHelper = new ComplexTypeHelper();
_definer = new Definer(simpleTypeChecker, complexTypeHelper);
_defContextFormatter = new DefContextFormatter(simpleTypeChecker, Encoding.Unicode);
}
/// <summary>
/// Beautifies the name of the type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="useFullName">if set to <c>true</c> [use full name].</param>
public static string BeautifyTypeName(this Type type, bool useFullName = false)
{
if (type == null || "Object".Equals(type.Name, StringComparison.OrdinalIgnoreCase))
{
return("object");
}
if (type == typeof(void))
{
return("void");
}
var workOnType = type;
var isNullable = false;
if (type.IsNullable() && type.GetGenericArguments().Length == 1)
{
isNullable = true;
workOnType = type.GetGenericArguments()[0];
}
string?typeName;
if (workOnType.IsByRef)
{
typeName = SimpleTypeHelper.GetBeautifyTypeNameByRef(workOnType);
}
else if (workOnType.IsArray)
{
typeName = SimpleTypeHelper.GetBeautifyArrayTypeName(workOnType);
}
else
{
typeName = SimpleTypeHelper.GetBeautifyTypeName(workOnType);
}
typeName ??= useFullName
? workOnType.FullName ?? workOnType.Name
: workOnType.Name;
if (isNullable &&
workOnType != typeof(string))
{
typeName += "?";
}
if (workOnType.IsByRef &&
typeName.Contains("&", StringComparison.Ordinal))
{
typeName += "&";
}
return(typeName);
}
public void GetBeautifyTypeNameByRef(Type type)
{
// Act
Exception exception = null;
try
{
SimpleTypeHelper.GetBeautifyTypeNameByRef(type);
}
catch (Exception ex)
{
exception = ex;
}
// Assert
Assert.NotNull(exception);
Assert.IsType <ArgumentException>(exception);
}
public static string EnsureModelNameWithNamespaceIfNeeded(
string projectName,
string segmentName,
string modelName,
bool isShared = false,
bool isClient = false)
{
if (string.IsNullOrEmpty(modelName))
{
return(string.Empty);
}
var isModelNameInNamespace = HasNamespaceRawModelName($"{projectName}.{segmentName}", modelName);
if (isModelNameInNamespace)
{
return(isClient
? modelName
: $"{projectName}.{NameConstants.Contracts}.{segmentName}.{modelName}");
}
if (!modelName.Contains('.', StringComparison.Ordinal) &&
!SimpleTypeHelper.IsSimpleType(modelName) &&
IsReservedTypeName(modelName))
{
if (isShared)
{
return($"{projectName}.{NameConstants.Contracts}.{modelName}");
}
if (isClient)
{
return($"{NameConstants.Contracts}.{modelName}");
}
return($"{projectName}.{NameConstants.Contracts}.{segmentName}.{modelName}");
}
return(modelName);
}
public SimpleTypeWriter(SimpleTypeHelper simpleTypeHelper, Encoding encoding)
{
_simpleTypeHelper = simpleTypeHelper;
_encoding = encoding;
_bytes = new SimpleList<byte>();
}
public BinaryFormatter(Encoding encoding)
{
var simpleTypeHelper = new SimpleTypeHelper();
_definer = new Definer(simpleTypeHelper, new ComplexTypeHelper());
_defContextFormatter = new DefContextFormatter(simpleTypeHelper, encoding);
}
public Definer(SimpleTypeHelper simpleTypeHelper, ComplexTypeHelper complexTypeHelper)
{
_simpleTypeHelper = simpleTypeHelper;
_complexTypeHelper = complexTypeHelper;
}
public void GetBeautifyArrayTypeName(string expected, Type type) => Assert.Equal(expected, SimpleTypeHelper.GetBeautifyArrayTypeName(type));
public DefContextFormatter(SimpleTypeHelper simpleTypeHelper, Encoding encoding)
{
if (encoding == null) throw new ArgumentNullException("encoding");
_simpleTypeHelper = simpleTypeHelper;
_encoding = encoding;
}
public ExpressionComparer()
{
_simpleTypeHelper = new SimpleTypeHelper();
}
