public void NameWithDotShouldBeEscaped()
{
var type = new TypeReference(_module, _module, "Company.ProductName", "Class.Name");
string name = TypeNameBuilder.GetAssemblyQualifiedName(type.ToTypeSignature());
Assert.Contains("Class\\.Name", name);
}
public void NamespaceShouldNotBeEscaped()
{
var type = new TypeReference(_module, _module, "Company.ProductName", "ClassName");
string name = TypeNameBuilder.GetAssemblyQualifiedName(type.ToTypeSignature());
Assert.DoesNotContain('\\', name);
Assert.Contains("Company.ProductName", name);
}
public void CorLibWithFullScope()
{
var type = _module.CorLibTypeFactory.Object;
string name = TypeNameBuilder.GetAssemblyQualifiedName(type, false);
Assert.Contains(type.FullName, name);
Assert.Contains(type.Scope.Name, name);
}
/// <inheritdoc />
protected override void WriteContents(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteByte((byte)NativeType);
writer.WriteSerString(Guid ?? string.Empty);
writer.WriteSerString(NativeTypeName ?? string.Empty);
writer.WriteSerString(MarshalType is null ? string.Empty : TypeNameBuilder.GetAssemblyQualifiedName(MarshalType));
writer.WriteSerString(Cookie ?? string.Empty);
}
public void NestedTypeNoNamespaceShouldContainPlus(string name, string nestedType)
{
var type = new TypeReference(_module, new TypeReference(_module, null, name), null, nestedType);
string fullname = TypeNameBuilder.GetAssemblyQualifiedName(type.ToTypeSignature());
Assert.DoesNotContain('\\', fullname);
Assert.Contains($"{name}+{nestedType}", fullname);
}
/// <inheritdoc />
protected override void WriteContents(BlobSerializationContext context)
{
var writer = context.Writer;
writer.WriteByte((byte)NativeType);
writer.WriteSerString(Guid ?? string.Empty);
writer.WriteSerString(NativeTypeName ?? string.Empty);
writer.WriteSerString(MarshalType is null ? string.Empty : TypeNameBuilder.GetAssemblyQualifiedName(MarshalType));
writer.WriteSerString(Cookie ?? string.Empty);
}
internal static void WriteFieldOrPropType(IBinaryStreamWriter writer, TypeSignature type)
{
switch (type.ElementType)
{
case ElementType.Boolean:
case ElementType.Char:
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.I:
case ElementType.U:
case ElementType.String:
writer.WriteByte((byte)type.ElementType);
break;
case ElementType.Object:
writer.WriteByte((byte)ElementType.Boxed);
break;
case ElementType.SzArray:
writer.WriteByte((byte)ElementType.SzArray);
var arrayType = (SzArrayTypeSignature)type;
WriteFieldOrPropType(writer, arrayType.BaseType);
break;
default:
if (type.IsTypeOf("System", "Type"))
{
writer.WriteByte((byte)ElementType.Type);
return;
}
var typeDef = type.Resolve();
if (typeDef != null && typeDef.IsEnum)
{
writer.WriteByte((byte)ElementType.Enum);
writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName(type));
return;
}
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Writes the security attribute to the provided output stream.
/// </summary>
public void Write(BlobSerializationContext context)
{
var writer = context.Writer;
string attributeTypeString;
if (AttributeType is null)
{
context.DiagnosticBag.RegisterException(new NullReferenceException(
"Attribute type of security attribute is null."));
attributeTypeString = null;
}
else
{
attributeTypeString = TypeNameBuilder.GetAssemblyQualifiedName(AttributeType);
}
writer.WriteSerString(attributeTypeString);
if (NamedArguments.Count == 0)
{
writer.WriteCompressedUInt32(1);
writer.WriteCompressedUInt32(0);
}
else
{
using var subBlob = new MemoryStream();
var subContext = new BlobSerializationContext(
new BinaryStreamWriter(subBlob),
context.IndexProvider,
context.DiagnosticBag);
subContext.Writer.WriteCompressedUInt32((uint)NamedArguments.Count);
foreach (var argument in NamedArguments)
{
argument.Write(subContext);
}
writer.WriteCompressedUInt32((uint)subBlob.Length);
writer.WriteBytes(subBlob.ToArray());
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual string Create(DbCommand command)
{
if (command.Parameters.Count == 0)
{
return(command.CommandText);
}
var builder = new StringBuilder();
foreach (DbParameter parameter in command.Parameters)
{
var typeName = TypeNameBuilder.CreateTypeName(parameter);
var typeMapping = _typeMapper.FindMapping(typeName);
builder
.Append("DECLARE ")
.Append(parameter.ParameterName)
.Append(' ')
.Append(typeName)
.Append(" = ")
.Append(
(parameter.Value == DBNull.Value ||
parameter.Value == null)
? "NULL"
: parameter.Value is SqlBytes sqlBytes
? new SqlServerByteArrayTypeMapping(typeName).GenerateSqlLiteral(sqlBytes.Value)
: typeMapping != null
? typeMapping.GenerateSqlLiteral(parameter.Value)
: parameter.Value.ToString())
.AppendLine(";");
}
return(builder
.AppendLine()
.Append(command.CommandText).ToString());
}
/// <summary>
/// Writes the security attribute to the provided output stream.
/// </summary>
/// <param name="writer">The output blob stream.</param>
/// <param name="provider">The object to use for obtaining metadata tokens for members in the tables stream.</param>
public void Write(IBinaryStreamWriter writer, ITypeCodedIndexProvider provider)
{
writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName(AttributeType));
if (NamedArguments.Count == 0)
{
writer.WriteCompressedUInt32(1);
writer.WriteCompressedUInt32(0);
}
else
{
using var subBlob = new MemoryStream();
var subWriter = new BinaryStreamWriter(subBlob);
subWriter.WriteCompressedUInt32((uint)NamedArguments.Count);
foreach (var argument in NamedArguments)
{
argument.Write(subWriter, provider);
}
writer.WriteCompressedUInt32((uint)subBlob.Length);
writer.WriteBytes(subBlob.ToArray());
}
}
public override async Task <object> InsertEventAsync(AuditEvent auditEvent)
{
var id = IdBuilder?.Invoke(auditEvent);
var createRequest = new CreateRequest <AuditEvent>(auditEvent, IndexBuilder?.Invoke(auditEvent), TypeNameBuilder?.Invoke(auditEvent), id);
var response = await _client.Value.CreateAsync(createRequest);
if (response.IsValid && response.Result != Result.Error)
{
return(new ElasticsearchAuditEventId()
{
Id = response.Id, Index = response.Index, Type = response.Type
});
}
if (response.OriginalException != null)
{
throw response.OriginalException;
}
return("/");
}
private void WriteValue(IBinaryStreamWriter writer, TypeSignature argumentType, ITypeCodedIndexProvider provider, object value)
{
if (argumentType.IsTypeOf("System", "Type"))
{
writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName((TypeSignature)value));
return;
}
switch (argumentType.ElementType)
{
case ElementType.Boolean:
writer.WriteByte((byte)((bool)value ? 1 : 0));
break;
case ElementType.Char:
writer.WriteUInt16((char)value);
break;
case ElementType.I1:
writer.WriteSByte((sbyte)value);
break;
case ElementType.U1:
writer.WriteByte((byte)value);
break;
case ElementType.I2:
writer.WriteInt16((short)value);
break;
case ElementType.U2:
writer.WriteUInt16((ushort)value);
break;
case ElementType.I4:
writer.WriteInt32((int)value);
break;
case ElementType.U4:
writer.WriteUInt32((uint)value);
break;
case ElementType.I8:
writer.WriteInt64((long)value);
break;
case ElementType.U8:
writer.WriteUInt64((ulong)value);
break;
case ElementType.R4:
writer.WriteSingle((float)value);
break;
case ElementType.R8:
writer.WriteDouble((double)value);
break;
case ElementType.String:
writer.WriteSerString(value as string);
break;
case ElementType.Object:
var valueType = value.GetType();
var innerTypeSig = argumentType.Module.CorLibTypeFactory.FromName(valueType.Namespace, valueType.Name);
TypeSignature.WriteFieldOrPropType(writer, innerTypeSig);
WriteValue(writer, innerTypeSig, provider, value);
break;
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
var enumTypeDef = argumentType.Resolve();
if (enumTypeDef != null && enumTypeDef.IsEnum)
{
WriteValue(writer, enumTypeDef.GetEnumUnderlyingType(), provider, Value);
}
else
{
throw new NotImplementedException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void WriteElement(TypeSignature argumentType, object element)
{
var writer = _context.Writer;
if (argumentType.IsTypeOf("System", "Type"))
{
writer.WriteSerString(TypeNameBuilder.GetAssemblyQualifiedName((TypeSignature)element));
return;
}
switch (argumentType.ElementType)
{
case ElementType.Boolean:
writer.WriteByte((byte)((bool)element ? 1 : 0));
break;
case ElementType.Char:
writer.WriteUInt16((char)element);
break;
case ElementType.I1:
writer.WriteSByte((sbyte)element);
break;
case ElementType.U1:
writer.WriteByte((byte)element);
break;
case ElementType.I2:
writer.WriteInt16((short)element);
break;
case ElementType.U2:
writer.WriteUInt16((ushort)element);
break;
case ElementType.I4:
writer.WriteInt32((int)element);
break;
case ElementType.U4:
writer.WriteUInt32((uint)element);
break;
case ElementType.I8:
writer.WriteInt64((long)element);
break;
case ElementType.U8:
writer.WriteUInt64((ulong)element);
break;
case ElementType.R4:
writer.WriteSingle((float)element);
break;
case ElementType.R8:
writer.WriteDouble((double)element);
break;
case ElementType.String:
writer.WriteSerString(element as string);
break;
case ElementType.Object:
TypeSignature innerTypeSig;
object value;
if (element is null)
{
// Most efficient way to store "null" is writing null as a string (two bytes).
innerTypeSig = argumentType.Module.CorLibTypeFactory.String;
value = null;
}
else if (element is BoxedArgument boxedArgument)
{
// Write the boxed argument.
innerTypeSig = boxedArgument.Type;
value = boxedArgument.Value;
}
else
{
_context.DiagnosticBag.RegisterException(new NotSupportedException(
$"Object elements in a custom attribute signature should be either 'null' or an instance of {nameof(BoxedArgument)}."));
// Write null as a recovery.
innerTypeSig = argumentType.Module.CorLibTypeFactory.String;
value = null;
}
TypeSignature.WriteFieldOrPropType(writer, innerTypeSig);
WriteElement(innerTypeSig, value);
break;
case ElementType.SzArray:
WriteArrayElement(
(SzArrayTypeSignature)argumentType,
element as IList <object> ?? new object[0],
element == null);
break;
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
WriteEnumValue(argumentType, element);
break;
default:
UnsupportedArgumentType(argumentType);
break;
}
}
/// <summary>
/// 根据类型获取代码名称
/// </summary>
/// <param name="type">类型</param>
/// <returns>代码名称</returns>
public static string fullName(this Type type)
{
return(TypeNameBuilder.GetFullName(type));
}
public override object InsertEvent(AuditEvent auditEvent)
{
var id = IdBuilder?.Invoke(auditEvent);
#pragma warning disable CS0618 // Type or member is obsolete
var createRequest = new CreateRequest <AuditEvent>(auditEvent, IndexBuilder?.Invoke(auditEvent), TypeNameBuilder?.Invoke(auditEvent), id);
#pragma warning restore CS0618 // Type or member is obsolete
var response = _client.Value.Create(createRequest);
if (response.IsValid && response.Result != Result.Error)
{
return(new ElasticsearchAuditEventId()
{
Id = response.Id, Index = response.Index, Type = response.Type
});
}
if (response.OriginalException != null)
{
throw response.OriginalException;
}
return("/");
}
