/// <inheritdoc />
public override string ToString()
{
return(Name +
(IsPointer ? new string('*', IndirectionLevels) : string.Empty) +
(IsArray ? Utilities.GetArrayDimensionString(ArrayDimensions) : string.Empty) +
(GenericTypes.Any() ? $"<{string.Join(", ", GenericTypes.Select(x => x.Name))}>" : string.Empty));
}
/// <summary>
/// ExecuteMessage
/// </summary>
/// <typeparam name="TResponse"></typeparam>
/// <param name="stream"></param>
/// <param name="message"></param>
/// <returns></returns>
protected override TResponse ExecuteMessage <TResponse>(NetworkStream stream, IQueueMessage message)
{
TResponse response = default(TResponse);
// Send a request from client to server
message.EntityWrite(stream, null);
if (message.DuplexType == DuplexTypes.None) //if (message.TransformType== TransformTypes.OneWay)
{
return(response);
}
// Receive a response from server.
//if (message.Command== QueueCmd.Enqueue)
if (typeof(IQueueAck).IsAssignableFrom(typeof(TResponse)))
{
var ack = MessageReader.ReadAckStream(stream, Settings.ReadTimeout, Settings.ReceiveBufferSize);
return(GenericTypes.Cast <TResponse>(ack));
}
var msg = MessageReader.ReadQStream(stream, Settings.ReadTimeout, Settings.ReceiveBufferSize);
return(GenericTypes.Cast <TResponse>(msg));
//response = Serialization.BinarySerializer.DeserializeFromStream<TResponse>(msg.BodyStream);
//response = message.ReadAck<TResponse>(stream, Settings.ProcessTimeout, Settings.ReceiveBufferSize);
//return response;
}
public string GenerateCode(CodeGenStyle style = null)
{
if (style == null)
{
style = new CodeGenStyle();
}
var builder = new StringBuilder();
if (Comment != null)
{
builder.AppendLine(Comment.GenerateCode(style));
}
foreach (var attribute in Attributes)
{
builder.AppendLine(attribute.GenerateCode(style));
}
builder.Append(style.Indent);
builder.Append(Scope.ToString().ToLower());
var genericList = GenericTypes.Select(gt => gt.Name).ToTypeParamList();
var argList = string.Join(", ", Parameters);
builder.Append($" delegate {ReturnType} {Name}{genericList}({argList});");
return(builder.ToString());
}
public bool IsEqualTo(TypeReference type)
{
if (Type != type.Type)
{
return(false);
}
if (GenericTypes?.Any() == true && type.GenericTypes?.Any() == true)
{
if (GenericTypes.Length != GenericTypes.Length)
{
return(false);
}
for (int i = 0; i < GenericTypes.Length; i++)
{
if (!GenericTypes[i].IsEqualTo(type.GenericTypes[i]))
{
return(false);
}
}
}
return(true);
}
public override void PreConvert()
{
if (GenericTypes.Count() > 0)
{
if (GenericTypes.All(t =>
{
if (t is GenericType gType)
{
return(gType.Constraints.Count() > 0);// All(c => c.DefaultValue != null);
}
return(false);
}))
{
var name = Name.Split(new char[] { '<' })[0];
var newClass = new ConcreteClass(Closure, name, Access, Partial, new Class[] { new GenericClass(null, name, AccessSpecifier.Public)
{
GenericTypes = GenericTypes.SelectMany(t => (t as GenericType).Constraints).ToList(),
} })
{
Methods = Methods.Where(m => m.IsConstructor).ToList()
};
}
}
base.PreConvert();
}
public bool FindCreateType()
{
if (BaseType != null)
{
if (IsGeneric)
{
if (GenericTypes.Count() == GenericCnt)
{
try
{
Type[] genericArray = GetGenericsAsArray();
if (genericArray.Count() == GenericCnt)
{
CreateType = BaseType.MakeGenericType(genericArray);
return(true);
}
}
catch
{
CreateType = null;
}
}
}
else
{
CreateType = BaseType;
}
if ((CreateType == null) && (Config != null))
{
CreateType = Config.InitType;
}
}
return(CreateType != null);
}
public override bool Equals(object obj)
{
GenericClass gClass = obj as GenericClass;
if (gClass != null && gClass != this && gClass.GenericTypes != null && GenericTypes != null)
{
if (gClass.GenericTypes.Count() == GenericTypes.Count())
{
List <Type> g1 = new List <Type>();
List <Type> g2 = new List <Type>();
g1.AddRange(GenericTypes);
g2.AddRange(gClass.GenericTypes);
foreach (var t1 in g1.ToList())
{
foreach (var t2 in g2.ToList())
{
if (t1.Equals(t2))
{
g1.Remove(t1);
g2.Remove(t2);
}
}
}
return(g1.Count == 0 && g2.Count == 0);
}
}
return(base.Equals(obj));
}
public override bool Equals(object obj)
{
GenericClass gClass = obj as GenericClass;
if (gClass != null)
{
if (Name.Equals(gClass.Name))
{
if (gClass.GenericTypes.Count() == GenericTypes.Count())
{
foreach (var t1 in GenericTypes)
{
foreach (var t2 in gClass.GenericTypes)
{
if (!t1.Equals(t2))
{
return(false);
}
}
}
return(true);
}
}
}
return(base.Equals(obj));
}
public string GenerateCode(CodeGenStyle style = null)
{
if (style == null)
{
style = new CodeGenStyle();
}
var builder = new StringBuilder();
if (Comment != null)
{
builder.AppendLine(Comment.GenerateCode(style));
}
foreach (var attribute in Attributes)
{
builder.AppendLine(attribute.GenerateCode(style));
}
builder.Append(style.Indent);
builder.Append(Scope.ToString().ToLower());
builder.Append(" ");
if (MethodType != MethodType.Normal)
{
builder.Append(MethodType.ToString().ToLower());
builder.Append(" ");
}
if (Async)
{
builder.Append("async ");
}
var genericList = GenericTypes.Select(gt => gt.Name).ToTypeParamList();
var argList = string.Join(", ", Parameters);
builder.AppendLine($"{ReturnType} {Name}{genericList}({argList})");
foreach (var constrainedGeneric in GenericTypes.Where(gt => gt.Constraint != null))
{
style.IndentCount++;
builder.AppendLine($"{style.Indent}where {constrainedGeneric.Name} : {constrainedGeneric.Constraint}");
style.IndentCount--;
}
builder.AppendLine($"{style.Indent}{{");
style.IndentCount++;
builder.AppendLine(style.IndentMultilineString(Body));
style.IndentCount--;
builder.Append($"{style.Indent}}}");
return(builder.ToString());
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
string genericTypes = string.Join(", ", GenericTypes.Select(cls => cls.Name));
if (GenericTypes.Count() > 0)
{
genericTypes = "<" + genericTypes + ">";
}
base.Write(formatter);
}
public override string ToString()
{
var str = Type.Name;
if (GenericTypes != null)
{
str += $"<{string.Join(",", GenericTypes.Select(x => x.ToString()))}>";
}
return(str);
}
public override string ToString()
{
var sb = new StringBuilder();
sb.Append("{");
sb.Append($"{nameof(InterfaceTypeFullName)}: '{InterfaceTypeFullName}', ");
sb.Append($"{nameof(GenericTypes)}: {GenericTypes.GetString()}, ");
sb.Append($"{nameof(Parameters)}: {Parameters.GetString()}, ");
sb.Append($"{nameof(ReturnTypeFullName)}: '{ReturnTypeFullName}'");
sb.Append("}");
return(sb.ToString());
}
public CSType ToCSType(CSUsingPackages use)
{
if (!String.IsNullOrEmpty(NameSpace))
{
use.AddIfNotPresent(NameSpace);
}
if (IsGenericReference)
{
CSGenericReferenceType genref = new CSGenericReferenceType(GenericDepth, GenericIndex);
if (this.GenericConstraints.Count > 0)
{
genref.InterfaceConstraints.AddRange(this.GenericConstraints.Select(ntb => ntb.ToCSType(use)));
}
return(genref);
}
return(Entity == EntityType.Tuple ? ToCSTuple(TupleTypes, use) :
new CSSimpleType(Type, false, GenericTypes.Select(ntb => ntb.ToCSType(use)).ToArray()));
}
public override string ToString()
{
var array = IsArray ? "[]" : string.Empty;
var nullable = IsNullable ? "?" : string.Empty;
var modifier = IsModifier ? "(M)" : string.Empty;
var interfaceString = IsInterface ? "(I)" : string.Empty;
var enumString = IsEnum ? $"(E)" : string.Empty;
var arguments = string.Join(
", ",
Arguments.Select(generic => generic.ToString())
);
var action = IsAction ? $"({arguments}) => " : string.Empty;
var genericsJoined = string.Join(
", ",
GenericTypes.Select(generic => generic.ToString())
);
var generics = GenericTypes.Any() ? $"<{genericsJoined}>" : string.Empty;
return($"{action} {enumString}{modifier}{interfaceString}{Name}{generics}{array}{nullable}");
}
public Type[] GetGenericsAsArray()
{
List <Type> generics = new List <Type>();
for (int i = 0; i < GenericTypes.Count(); i++)
{
if (!GenericTypes[i].FindBaseType())
{
GenericTypes[i].BaseType = TypeFactory.GetInstance().FindBaseType(GenericTypes[i]);
}
if ((GenericTypes[i].BaseType != null) && GenericTypes[i].FindCreateType())
{
generics.Add(GenericTypes[i].CreateType);
}
else
{
break;
}
}
return(generics.ToArray());
}
protected override TResponse ExecuteMessage <TResponse>(IQueueMessage message)
{
TResponse response = default(TResponse);
if (PipeDirection != System.IO.Pipes.PipeDirection.In)
{
// Send a request from client to server
message.EntityWrite(pipeClientStream, null);
}
if (PipeDirection == System.IO.Pipes.PipeDirection.Out)
{
return(response);
}
if (typeof(IQueueAck).IsAssignableFrom(typeof(TResponse)))
{
var ack = MessageReader.ReadAckStream(pipeClientStream, Settings.ReceiveBufferSize);
return(GenericTypes.Cast <TResponse>(ack));
}
//if (message.Command== QueueCmd.Enqueue)
//{
// var ack = MessageReader.ReadAckStream(pipeClient, Settings.ReceiveBufferSize);
// return GenericTypes.Cast<TResponse>(ack);
//}
// Receive a response from server.
var msg = MessageReader.ReadQStream(pipeClientStream, Settings.ReceiveBufferSize);
return(GenericTypes.Cast <TResponse>(msg));
//response = Serialization.BinarySerializer.DeserializeFromStream<TResponse>(msg.BodyStream);
//return response;
//var ack = MessageReader.ReadAck(pipeClient, Settings.ReceiveBufferSize);
//return GenericTypes.Cast<TResponse>(res);
//response = message.ReadAck<TResponse>(pipeClient, Settings.ReceiveBufferSize);
}
public override int GetHashCode()
{
unchecked
{
return(((BaseMethod != null ? BaseMethod.GetHashCode() : 0) * 397) ^ (GenericTypes != null ? GenericTypes.GetHashCode() : 0));
}
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="node">対象Node</param>
/// <param name="semanticModel">対象ソースのsemanticModel</param>
/// <param name="parent">親IAnalyzeItem</param>
/// <param name="container">イベントコンテナ</param>
public ItemInterface(InterfaceDeclarationSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container)
{
ItemType = ItemTypes.Interface;
var declaredSymbol = semanticModel.GetDeclaredSymbol(node);
// インターフェース設定
if (node.BaseList != null)
{
// インターフェース
foreach (var interfaceInfo in declaredSymbol.AllInterfaces)
{
Interfaces.Add(getExpressionList(interfaceInfo));
// スーパーインタフェースのメンバーを追加する
SetBaseMembers(interfaceInfo);
}
// 対象をList<IExpression>に格納する
List <IExpression> getExpressionList(INamedTypeSymbol target)
{
var result = new List <IExpression>();
var displayParts = target.ToDisplayParts(SymbolDisplayFormat.MinimallyQualifiedFormat);
foreach (var part in displayParts)
{
// スペースの場合は型設定に含めない
if (part.Kind == SymbolDisplayPartKind.Space)
{
continue;
}
var name = Expression.GetSymbolName(part, true);
var type = Expression.GetSymbolTypeName(part.Symbol);
if (part.Symbol != null)
{
type = part.Symbol.GetType().Name;
if (part.Kind == SymbolDisplayPartKind.ClassName || part.Kind == SymbolDisplayPartKind.InterfaceName)
{
// 外部ファイル参照イベント発行
RaiseOtherFileReferenced(node, part.Symbol);
}
}
result.Add(new Expression(name, type));
}
return(result);
}
}
// ジェネリックタイプ
if (declaredSymbol.TypeParameters.Any())
{
var types = declaredSymbol.TypeParameters.Select(item => item.Name);
GenericTypes.AddRange(types);
}
// メンバ
foreach (var childSyntax in node.ChildNodes())
{
var memberResult = ItemFactory.Create(childSyntax, semanticModel, container, this);
if (memberResult != null)
{
Members.Add(memberResult);
}
}
}
public InterfaceModel WithGenericTypes(params TypeModel[] types)
{
GenericTypes.AddRange(types);
return(this);
}
public string GenerateCode(CodeGenStyle style = null)
{
if (style == null)
{
style = new CodeGenStyle();
}
var builder = new StringBuilder();
if (Comment != null)
{
builder.AppendLine(Comment.GenerateCode(style));
}
foreach (var attribute in Attributes)
{
builder.AppendLine(attribute.GenerateCode(style));
}
builder.Append(style.Indent);
builder.Append(Scope.ToString().ToLower());
builder.Append(" ");
if (ClassType != ClassType.Normal)
{
builder.Append(ClassType.ToString().ToLower());
builder.Append(" ");
}
var genericList = GenericTypes.Any() ? $"<{string.Join(", ", GenericTypes.Select(gt => gt.Name))}>" : string.Empty;
builder.Append($"class {Name}{genericList}");
if (DerivedFrom.Any())
{
var derivedFromList = string.Join(", ", DerivedFrom);
builder.Append($" : {derivedFromList}");
}
builder.AppendLine();
foreach (var constrainedGeneric in GenericTypes.Where(gt => gt.Constraint != null))
{
style.IndentCount++;
builder.AppendLine($"{style.Indent}where {constrainedGeneric.Name} : {constrainedGeneric.Constraint}");
style.IndentCount--;
}
builder.AppendLine($"{style.Indent}{{");
style.IndentCount++;
foreach (var constructor in Constructors)
{
builder.AppendLine(constructor.GenerateCode(style));
builder.AppendLine();
}
foreach (var variable in Variables)
{
builder.AppendLine(variable.GenerateCode(style));
builder.AppendLine();
}
foreach (var property in Properties)
{
builder.AppendLine(property.GenerateCode(style));
builder.AppendLine();
}
foreach (var method in Methods)
{
builder.AppendLine(method.GenerateCode(style));
builder.AppendLine();
}
style.IndentCount--;
builder.Append($"{style.Indent}}}");
return(builder.ToString());
}
private static VersionedTypeInfo[] CreateVersionedTypeInfos()
{
var vtis = new VersionedTypeInfo[VersionedProperties.Length];
var enumerableTypes = new Type[vtis.Length];
for (var i = 0; i != vtis.Length; ++i)
{
var propertyInfo = VersionedProperties[i];
var gts = GenericTypes.GetGenericTypes(propertyInfo);
enumerableTypes[i] = typeof(IEnumerable <>).MakeGenericType(gts.Version);
var allMutupleGenericTypes = new[] { typeof(T) }.Concat(enumerableTypes.TakeWhile(x => x != null)).ToArray();
var vti = new VersionedTypeInfo();
vti.PropertyInfo = propertyInfo;
vti.GenericTypes = gts;
vti.MutupleType = MutupleTypes.Single(x => x.GetGenericArguments().Length == i + 2);
vti.OuterType = i == 0 ? typeof(Mutuple <T>) : vtis[i - 1].ResultType;
vti.ResultType = vti.MutupleType.MakeGenericType(allMutupleGenericTypes);
vti.GroupJoinMethodInfo = (MethodInfo)typeof(GroupJoinCache <, , ,>).MakeGenericType(vti.OuterType, gts.Version, typeof(Guid), vti.ResultType)
.GetField(nameof(GroupJoinCache <Object, Object, Object, Object> .GroupJoinMethodInfo))
.GetValue(null);
vti.GetInnerSourceExpressionFunc = (Func <DbContext, Expression>) typeof(VersionedBaseTypeCache <, , ,>).MakeGenericType(gts.Versioned, gts.Value, gts.Version, gts.IVersions)
.GetField(nameof(VersionedBaseTypeCache <VersionedString, String, StringVersion, IStringVersions> .GetSourceExpressionFunc))
.GetValue(null);
var param = Expression.Parameter(vti.OuterType, "m");
var outerKeySelector =
Expression.Lambda(
Expression.Property(
Expression.Property(
Expression.Property(param, nameof(Mutuple <Object> .Item1)),
vti.PropertyInfo.Name
),
nameof(VersionedBoolean.Id)
),
param
);
vti.OuterKeySelectorExpression = Expression.Quote(outerKeySelector);
param = Expression.Parameter(vti.GenericTypes.Version, "v");
var innerKeySelector = Expression.Lambda(Expression.Property(param, nameof(BooleanVersion.VersionedId)), param);
vti.InnerKeySelectorExpression = Expression.Quote(innerKeySelector);
var mutupleParameterExpression = Expression.Parameter(vti.OuterType, "m");
var versionsParameterExpression = Expression.Parameter(enumerableTypes[i], "vs");
var enumerableMemberAssignments = Enumerable.Range(0, i + 1).Select(x => Expression.Bind(vti.ResultType.GetProperty($"Item{x+1}"), Expression.Property(mutupleParameterExpression, $"Item{x + 1}")));
var memberAssignments = enumerableMemberAssignments.Concat(new [] { Expression.Bind(vti.ResultType.GetProperty($"Item{i+2}"), versionsParameterExpression) }).ToArray();
var resultSelector = Expression.Lambda(Expression.MemberInit(Expression.New(vti.ResultType), memberAssignments), mutupleParameterExpression, versionsParameterExpression);
vti.ResultSelectorExpression = Expression.Quote(resultSelector);
vtis[i] = vti;
}
var last = vtis.Last();
last.SelectNewType = last.MutupleType.MakeGenericType(new[] { typeof(T) }.Concat(vtis.TakeWhile(x => x != null).Select(x => x.GenericTypes.Version)).ToArray());
last.SelectMethodInfo = (MethodInfo)typeof(SelectCache <,>).MakeGenericType(last.ResultType, last.SelectNewType).GetField(nameof(SelectCache <Object, Object> .SelectMethodInfo)).GetValue(null);
var parameterExpression = Expression.Parameter(last.ResultType, "m");
var newExpression = Expression.New(last.SelectNewType);
var t = Expression.Bind(last.SelectNewType.GetProperty(nameof(Mutuple <Object> .Item1)), Expression.Property(parameterExpression, last.ResultType.GetProperty(nameof(Mutuple <Object> .Item1))));
var memberBindingExpressions = new [] { t }.Concat(vtis.Select((x, i) => {
var firstOrDefaultMethodInfo = (MethodInfo)typeof(FirstOrDefaultCache <>).MakeGenericType(x.GenericTypes.Version).GetField(nameof(FirstOrDefaultCache <Object> .FirstOrDefaultMethodInfo)).GetValue(null);
var orderByMethodInfo = (MethodInfo)typeof(OrderByDateTimeCache <>).MakeGenericType(x.GenericTypes.Version).GetField(nameof(OrderByDateTimeCache <Object> .OrderByMethodInfo)).GetValue(null);
var versionParameterExpression = Expression.Parameter(x.GenericTypes.Version, "x");
return(Expression.Bind(last.SelectNewType.GetProperty($"Item{i + 2}"),
Expression.Call(
null,
firstOrDefaultMethodInfo,
Expression.Call(
null,
orderByMethodInfo,
Expression.Property(parameterExpression, $"Item{i + 2}"),
Expression.Lambda(
Expression.Property(
versionParameterExpression, nameof(VersionBase <Object> .Added)
),
versionParameterExpression
)
),
Expression.Lambda(
Expression.GreaterThanOrEqual(
Expression.Property(versionParameterExpression, nameof(VersionBase <Object> .Added)),
Expression.Property(null, typeof(EntityVersionedTypeCache <>).MakeGenericType(typeof(T)).GetProperty(nameof(ThreadLocalDateTime))), //Expression.Constant(DateTime.UtcNow, typeof(DateTime)),
false, // liftToNull
typeof(DateTime).GetMethod("op_GreaterThanOrEqual")
),
versionParameterExpression
)
)
));
}));
var selector = Expression.Lambda(
Expression.MemberInit(newExpression, memberBindingExpressions),
parameterExpression
);
last.SelectExpression = Expression.Quote(selector);
return(vtis);
}
/// <summary>
/// Deserialize body stream to generic object.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T GetBody <T>()
{
return(GenericTypes.Cast <T>(GetBody()));
}
/// <summary>
/// 文字列取得
/// </summary>
/// <param name="index">前スペース数</param>
/// <returns>文字列</returns>
public override string ToString(int index = 0)
{
var result = new StringBuilder();
var indexSpace = string.Concat(Enumerable.Repeat(" ", index));
foreach (var comment in Comments)
{
result.Append(indexSpace);
result.AppendLine($"{comment}");
}
foreach (var modifier in Modifiers)
{
result.Append(indexSpace);
result.Append($"{modifier} ");
}
result.Append($"class {Name}");
// ジェネリックタイプ
if (GenericTypes.Any())
{
result.Append("<");
GenericTypes.ForEach(item => {
result.Append(item);
if (GenericTypes.IndexOf(item) > 0)
{
result.Append(", ");
}
});
result.Append(">");
}
// スーパークラス/インターフェイス
if (SuperClass.Any())
{
result.Append(" : ");
SuperClass.ForEach(item => {
result.Append(item.Name);
});
}
if (Interfaces.Any())
{
if (SuperClass.Any())
{
result.Append(", ");
}
Interfaces.ForEach(item => {
if (Interfaces.IndexOf(item) > 0)
{
result.Append(", ");
}
item.ForEach(expression =>
{
result.Append(expression.Name);
});
});
}
result.AppendLine();
result.Append(indexSpace);
result.AppendLine("{");
Members.ForEach(member => result.AppendLine(member.ToString(index + 1)));
result.Append(indexSpace);
result.AppendLine("}");
return(result.ToString());
}
