public IEnumerable <StepBindingNew> GetBindingsFromProjectItem(ProjectItem projectItem)
{
foreach (CodeClass bindingClassWithBindingAttribute in VsxHelper.GetClasses(projectItem).Where(IsBindingClass))
{
BindingScopeNew[] bindingScopes = GetClassScopes(bindingClassWithBindingAttribute);
CodeClass2 bindingClassIncludingParts = bindingClassWithBindingAttribute as CodeClass2;
if (bindingClassIncludingParts == null)
{
foreach (StepBindingNew currrentFoundStep in GetStepsFromClass(bindingClassWithBindingAttribute, bindingScopes))
{
yield return(currrentFoundStep);
}
}
else
{
foreach (CodeClass2 currentBindingPartialClass in bindingClassIncludingParts.Parts)
{
foreach (StepBindingNew currentPartialClassStep in GetStepsFromClass(currentBindingPartialClass as CodeClass, bindingScopes))
{
yield return(currentPartialClassStep);
}
}
}
}
}
/// <summary>
/// 根据DTE获取CodeClass2
/// </summary>
/// <param name="dte"></param>
/// <returns></returns>
public static CodeClass2 GetCodeClass2(DTE dte)
{
CodeClass2 codeClzz = null;
if (dte == null)
{
return(codeClzz);
}
var item = dte.ActiveDocument.ProjectItem;
var codeModel = item.FileCodeModel;
var eles = codeModel.CodeElements;
foreach (CodeElement element in eles)
{
string codeKind = element.Kind.ToString();
//查找命名空间
if (element.Kind == vsCMElement.vsCMElementNamespace)
{
foreach (CodeElement c in element.Children)
{
//定位到类
if (c.Kind == vsCMElement.vsCMElementClass)
{
codeClzz = c as CodeClass2;
}
}
}
}
return(codeClzz);
}
/// <summary>
/// Build inicializer for given class.
/// </summary>
/// <param name="element">Class which initializer will be created.</param>
/// <returns>Created initializer.</returns>
private MethodItem buildInitializer(CodeClass2 element)
{
var initializerSource = new StringBuilder();
initializerSource.AppendLine("{");
foreach (var child in element.Children)
{
var initializable = child as CodeVariable2;
if (
initializable == null ||
initializable.InitExpression == null ||
initializable.IsShared != MethodInfo.IsStatic
)
{
continue;
}
initializerSource.Append(initializable.Name);
initializerSource.Append(" = ");
initializerSource.Append(initializable.InitExpression);
initializerSource.AppendLine(";");
}
initializerSource.Append("}");
var sourceCode = initializerSource.ToString();
return(buildFromSource(element, sourceCode));
}
private void ProcessBindingsFromProjectItem(ProjectItem projectItem, IdeBindingSourceProcessor bindingSourceProcessor, List <ProjectItem> relatedProjectItems)
{
foreach (CodeClass codeClass in VsxHelper.GetClasses(projectItem))
{
CodeClass2 bindingClassIncludingParts = codeClass as CodeClass2;
var parts = new List <CodeClass>();
if (bindingClassIncludingParts == null)
{
parts.Add(codeClass);
}
else
{
parts.AddRange(bindingClassIncludingParts.Parts.OfType <CodeClass>());
}
var baseClass = GetBaseClass(codeClass);
while (baseClass != null)
{
tracer.Trace("Adding inherited bindings for class: " + baseClass.FullName, GetType().Name);
parts.Add(baseClass);
baseClass = GetBaseClass(baseClass);
}
// we need to use the class parts to grab class-related information (e.g. [Binding] attribute)
// but we need to process the binding methods only from the current part, otherwise these
// methods would be registered to multiple file paths, and the update tracking would not work
relatedProjectItems.AddRange(parts.Select(SafeGetProjectItem).Where(pi => pi != null && pi != projectItem));
ProcessCodeClass(codeClass, bindingSourceProcessor, parts.ToArray());
}
}
private static CodeProperty2[] GetExistingSets(CodeClass2 cls)
{
var setProps = cls.GetProperties()
.Where(p => p.Type.AsFullName.StartsWith(_GetExistingSets_DbsetTypeName));
return setProps.ToArray();
}
/// <summary>
/// Initializes a new instance of the <see cref="ClassInfo"/> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="item">The item.</param>
public ClassInfo(NodeItem parent, CodeClass2 item)
: base(null, item as CodeElement2)
{
this.Parent = parent;
this.item = item;
this.IsClass = true;
this.Access = ObjectFactory.Convert(this.item.Access);
this.IsAbstract = this.item.IsAbstract;
this.IsShared = this.item.IsShared;
this.IsGeneric = this.item.IsGeneric;
this.Namespace = item.Namespace.FullName;
this.DocComment = this.item.DocComment;
IsPublic = this.IsPublic_Impl(this.item.Access);
IsPrivate = this.IsPrivate_Impl(this.item.Access);
IsProtected = this.IsProtected_Impl(this.item.Access);
IsFamilyOrProtected = this.IsFamilyOrProtected_Impl(this.item.Access);
this.IsStatic = false;
this.IsStruct = false;
//this.item.Children
//this.item.DerivedTypes
//this.item.InfoLocation
//this.item.InheritanceKind
//this.item.Kind = vsCMElement.
//this.item.Parent
//this.item.PartialClasses
//this.item.Parts
}
public static CodeElements GetCodeElementMembers(CodeElement codeElement)
{
if (codeElement.Kind == vsCMElement.vsCMElementClass)
{
CodeClass2 codeClass = (CodeClass2)codeElement;
return(codeClass.Members);
}
else if (codeElement.Kind == vsCMElement.vsCMElementInterface)
{
CodeInterface2 codeInterface = (CodeInterface2)codeElement;
return(codeInterface.Members);
}
else if (codeElement.Kind == vsCMElement.vsCMElementStruct)
{
CodeStruct2 codeStruct = (CodeStruct2)codeElement;
return(codeStruct.Members);
}
else if (codeElement.Kind == vsCMElement.vsCMElementEnum)
{
CodeEnum codeEnum = (CodeEnum)codeElement;
return(codeEnum.Members);
}
else if (codeElement.Kind == vsCMElement.vsCMElementNamespace)
{
CodeNamespace codeNamespace = (CodeNamespace)codeElement;
return(codeNamespace.Members);
}
return(null);
}
/// <summary>
/// 获取类的所有Property信息
/// </summary>
/// <param name="codeClass"></param>
/// <param name="isRecursive">是否递归获取父类的信息</param>
/// <returns></returns>
public static List <CodeProperty2> GetCodeProperty2s(CodeClass2 codeClass, bool isRecursive = false)
{
List <CodeProperty2> list = new List <CodeProperty2>();
//获取基类的属性信息
if (isRecursive && codeClass.Bases.Count > 0)
{
var baseElements = codeClass.Bases as CodeElements;
if (baseElements != null)
{
CodeClass2 clazz = GetCodeClass2(baseElements);
list.AddRange(GetCodeProperty2s(clazz));
}
}
//获取当前类的属性
foreach (CodeElement prop in codeClass.Members)
{
if (prop.Kind == vsCMElement.vsCMElementProperty)
{
CodeProperty2 p = prop as CodeProperty2;
list.Add(p);
}
else if (prop.Kind == vsCMElement.vsCMElementVariable)
{
CodeVariable2 v = prop as CodeVariable2;
}
else
{
Console.WriteLine("" + prop.Kind);
}
}
return(list);
}
public static bool IsConstructorDefined(CodeClass2 codeClass, CodeVariable2[] codeVariables)
{
List <CodeFunction2> constructors = GetConstructors(codeClass);
foreach (CodeFunction2 constructor in constructors)
{
if (constructor.Parameters.Count == codeVariables.Length)
{
bool areEqual = true;
foreach (CodeElement codeElement in constructor.Parameters)
{
CodeParameter2 codeParameter = (CodeParameter2)codeElement;
if (!ContainsType(codeVariables, codeParameter.Type.AsFullName))
{
areEqual = false;
break;
}
}
if (areEqual)
{
return(true);
}
}
}
return(false);
}
internal bool markType(Lookup lookup, Projects projects)
{
foreach (Project p in projects)
{
try
{
if (p.CodeModel != null)
{
CodeClass2 codeClass = (CodeClass2)p.CodeModel.CodeTypeFromFullName(lookup.typeName);
if (codeClass != null)
{
try
{
object test = codeClass.ProjectItem;
dte.Documents.Open(codeClass.ProjectItem.get_FileNames(0), "Auto", false);
TextSelection textSelection = (TextSelection)dte.ActiveDocument.Selection;
textSelection.MoveToLineAndOffset(codeClass.StartPoint.Line, codeClass.StartPoint.LineCharOffset, false);
dte.MainWindow.Activate();
log(String.Format(Context.LOG_INFO + "Method {0} not found but type {1} -> marking type", lookup.methodName, lookup.typeName));
return(true);
}
catch (System.Runtime.InteropServices.COMException) { }
}
}
}
catch (NotImplementedException) { }
catch (Exception e)
{
log(Context.LOG_ERROR + e.ToString());
}
}
log(Context.LOG_WARN + "Could not find the Type \"" + lookup.typeName + "\"!");
return(false);
}
/// <summary>
/// Determine that given class has parameter less constructor (implicit or not)
/// </summary>
/// <param name="element">Class element to be tested</param>
/// <returns><c>true</c> if class has parameter less constructor, <c>false</c> otherwise</returns>
private bool hasParamLessConstructor(CodeClass2 element)
{
var hasImplicitParamLessCtor = true;
foreach (var member in element.Members)
{
var function = member as CodeFunction;
if (function == null)
{
continue;
}
if (function.FunctionKind == vsCMFunction.vsCMFunctionConstructor)
{
//there already exist constructor which prohibits implicit one
hasImplicitParamLessCtor = false;
if (function.Parameters.Count == 0)
{
//param less ctor exist - implicit composition point is possible
return(true);
}
}
}
//no constructor that prohibits implicit compositoin point exist
return(hasImplicitParamLessCtor);
}
public static DbsetDialogResult ShowDialog(ProjectItem prjItem, CodeClass2 cls, string[] existingSets)
{
var dlg = new DbsetDialog { ProjectItem = prjItem, ContextClass = cls , _existingSets = existingSets};
dlg.Init();
dlg.ShowDialog();
return dlg._isGenerated ? new DbsetDialogResult(dlg.CandidateList.SelectedItems.Cast<DbsetCandidate>().ToArray(),true) : null;
}
private string RenameClasses(CodeElement item)
{
//try
//{
if (item.Kind == vsCMElement.vsCMElementImportStmt)
{
return("");
}
CodeClass2 codeClass2 = item as CodeClass2;
//if (hasHandleClasses.Contains(item.Name) && codeClass2.ClassKind != vsCMClassKind.vsCMClassKindPartialClass)
// return "";
//if (item.Name.Contains(alien))
// return "";
PrintItemInfo(item);
//var sb = new StringBuilder();
RenameClass(item);
//Debug.WriteLine("RenameClasses.FullName:" + item.FullName);
var projCount = item.Children.Count;
var index = 0;
foreach (CodeElement code in item.Children)
{
var res = RenameClass(code);
}
//}
//catch { }
//return sb.ToString();
return("");
}
/// <inheritdoc />
public override void VisitClass(CodeClass2 e)
{
base.VisitClass(e);
if (_builtComponents.ContainsKey(e))
{
//component has been found
var componentBuilder = _builtComponents[e];
if (!componentBuilder.HasImportingCtor)
{
if (hasParamLessConstructor(e))
{
componentBuilder.AddImplicitImportingConstructor();
}
}
//check componet's implicit composition point
if (!componentBuilder.HasCompositionPoint)
{
if (hasParamLessConstructor(e))
{
componentBuilder.AddImplicitCompositionPoint();
}
}
var componentInfo = componentBuilder.Build();
OnComponentFound(componentInfo);
}
}
public void initialize_constructor()
{
TextSelection selection = studio.ActiveDocument.Selection as TextSelection;
CodeClass2 class_object = (CodeClass2)selection.ActivePoint.get_CodeElement(vsCMElement.vsCMElementClass);
CodeFunction2 constructor = class_object.AddFunction(class_object.Name, vsCMFunction.vsCMFunctionConstructor,
vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessPublic, 0) as CodeFunction2;
string text = "";
foreach (CodeElement2 member in class_object.Members)
{
if (member.Kind == vsCMElement.vsCMElementVariable)
{
CodeVariable2 variable = member as CodeVariable2;
CodeParameter2 parameter = constructor.AddParameter("new_" + variable.Name, variable.Type, -1) as CodeParameter2;
text += "\r\n" + variable.Name + " = " + parameter.Name + ";";
}
else if (member.Kind == vsCMElement.vsCMElementProperty)
{
var variable = member as CodeProperty;
// CodeTypeRef new_type =
CodeParameter2 parameter = constructor.AddParameter("new_" + variable.Name, variable.Type, -1) as CodeParameter2;
text += "\r\n" + variable.Name + " = " + parameter.Name + ";";
}
}
EditPoint2 point = constructor.EndPoint.CreateEditPoint() as EditPoint2;
point.LineUp(1);
point.Insert(text);
selection.MoveToPoint(constructor.StartPoint, false);
selection.MoveToPoint(constructor.EndPoint, true);
selection.SmartFormat();
selection.MoveToPoint(point, false);
}
public static CodeProperty2[] GetAutoProperties(this CodeClass2 cls)
{
var props = cls.GetProperties().ToArray();
Func <CodeProperty, bool> isAutoProperty = x => !x.Setter.GetText().Contains("{");
return(props.Where(x => x.ReadWrite == vsCMPropertyKind.vsCMPropertyKindReadWrite &&
isAutoProperty(x) && x.OverrideKind != vsCMOverrideKind.vsCMOverrideKindAbstract).ToArray());
}
public static IEnumerable<CodeClass2> ShowDialog(ProjectItem prjItem, CodeClass2 cls, BaseclassSelectionChangedHandler selectionHandler)
{
var dlg = new DbSetDialog {ProjectItem = prjItem, TargetClass = cls};
var baseClassCandidates = dlg.GetClassesFromSameNamespace(cls);
dlg.baseclassCombo.DataSource = baseClassCandidates;
dlg.ShowDialog();
return dlg.classesList.SelectedItems.Cast<CodeClass2>();
}
public static IEnumerable <CodeClass2> GetSubclasses(this CodeClass2 cc)
{
var fullname = cc.FullName;
var list = new List <CodeClass2>();
Kodeo.Reegenerator.Wrappers.CodeElement.TraverseSolutionForCodeElements <CodeClass2>(
cc.DTE.Solution, list.Add, x => x.FullName != fullname && x.IsDerivedFrom[fullname]);
return(list.ToArray());
}
public void Item_OneClassCompletionEntryAndItemSelectedByName_ReturnsOneCodeClass()
{
helper.AddClassToProjectContentAndCompletionEntries("Test", "Test.MyClass");
CreateCodeElements("Test");
CodeClass2 codeClass = codeElements.Item("MyClass") as CodeClass2;
Assert.AreEqual("Test.MyClass", codeClass.FullName);
}
/// <summary>
/// Creates a test file named 'SecuredTests.cs' that contains all the test methods.
/// </summary>
/// <param name="p_methods"></param>
public static void CreateTestFile(Dictionary <TestingMethodVM, List <TestConfiguration> > p_methods)
{
DTE2 dte = (DTE2)Secure_TDDPackage.GetGlobalService(typeof(DTE));
Solution2 soln = (Solution2)dte.Solution;
Project currentProj = dte.ActiveDocument.ProjectItem.ContainingProject;
Project proj = GetTestingProject(currentProj);
ProjectItem pi = GetCSTestFile(proj, soln);
FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
if (!IsContainImports(fcm))
{
fcm.AddImport("System");
fcm.AddImport("System.Linq");
fcm.AddImport("System.Text");
fcm.AddImport("System.Collections.Generic");
fcm.AddImport("Microsoft.VisualStudio.TestTools.UnitTesting");
}
string namespaceName = "Testing";
CodeNamespace testingNameSpace = GetNamespace(fcm, namespaceName);
if (testingNameSpace != null)
{
string className = "SecuredTestClass";
CodeClass2 securedClass = GetClass(fcm, testingNameSpace, className);
foreach (var methodKeyValue in p_methods)
{
var startIndexOfMethodName = methodKeyValue.Key.FullName.LastIndexOf('.');
var methodBaseName = methodKeyValue.Key.FullName.Substring(startIndexOfMethodName + 1) + "_{0}Test";
foreach (var testConfiguration in methodKeyValue.Value)
{
// Remove all white-spaces in the test name.
var fixedName = testConfiguration.Name.Replace(" ", string.Empty);
var methodName = string.Format(methodBaseName, fixedName);
var functionBody = GetMethodBody(methodKeyValue.Key, testConfiguration);
AddFunction(securedClass, methodName, functionBody);
}
}
}
// if the file is not opened in the text editor, open and activate it.
Window window = pi.Open(Constants.vsViewKindCode);
if (window != null)
{
window.Activate();
dte.ExecuteCommand("Edit.FormatDocument");
}
// Save the file.
pi.Save();
}
/// <summary>
/// Creates <see cref="TypeMethodInfo"/> for given element
/// </summary>
/// <param name="element">Element which <see cref="TypeMethodInfo"/> is created</param>
/// <returns>Created <see cref="TypeMethodInfo"/></returns>
protected TypeMethodInfo BuildFrom(CodeClass2 element)
{
var declaringType = CreateDescriptor(element);
var methodInfo = new TypeMethodInfo(
declaringType, RequiredName, TypeDescriptor.Void, ParameterTypeInfo.NoParams,
false, TypeDescriptor.NoDescriptors, false
);
return(methodInfo);
}
public void CodeElements_OneClassWithNoNamespaceInProject_ReturnsOneCodeClassItem()
{
CreateCodeModel();
AddClassToProjectContent(String.Empty, "TestClass");
CodeElements codeElements = codeModel.CodeElements;
CodeClass2 codeClass = codeElements.FirstCodeClass2OrDefault();
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("TestClass", codeClass.FullName);
}
public static bool ContainsMember(CodeClass2 codeClass, string memberName)
{
foreach (CodeElement member in codeClass.Members)
{
if (member.Name == memberName)
{
return(true);
}
}
return(false);
}
public void CodeType_ReturnTypeIsSystemString_ReturnsCodeClass2ForSystemStringType()
{
helper.CreateReturnType("System.String");
AddUnderlyingClassToReturnType("System.String");
CreateCodeTypeRef2();
CodeClass2 codeClass = typeRef.CodeType as CodeClass2;
string name = codeClass.FullName;
Assert.AreEqual("System.String", name);
}
/// <summary>
/// Build <see cref="MethodItem" /> from given <see cref="CodeClass2" /> element.
/// </summary>
/// <param name="element">Method definition element.</param>
/// <returns>Built method.</returns>
protected MethodItem BuildFrom(CodeClass2 element)
{
var isImplicitCtor = Naming.IsParamLessCtor(MethodInfo.MethodID) || Naming.IsClassCtor(MethodInfo.MethodID);
if (isImplicitCtor)
{
return(buildImplicitCtor(element));
}
return(buildInitializer(element));
}
/// <summary>
/// Build implicit ctor or initializer method from given source.
/// </summary>
/// <param name="element">Element which method is built.</param>
/// <param name="sourceCode">Code of method.</param>
/// <returns>Built method.</returns>
private MethodItem buildFromSource(CodeClass2 element, string sourceCode)
{
var namespaces = DeclaringAssembly.GetNamespaces(element as CodeElement);
var activation = new ParsingActivation(sourceCode, MethodInfo, new string[0], namespaces);
RegisterActivation(activation, element as CodeElement);
var generator = new SourceMethodGenerator(activation, DeclaringAssembly.ParsingProvider);
return(new MethodItem(generator, MethodInfo));
}
public void CodeElements_OneClassWithNoNamespaceInProject_ReturnsOneCodeClassItem()
{
CreateCodeModel();
AddClassToProject("public class TestClass { }");
global::EnvDTE.CodeElements codeElements = codeModel.CodeElements;
CodeClass2 codeClass = codeElements
.FindFirstCodeClass2OrDefault(e => e.FullName == "TestClass");
Assert.AreEqual("TestClass", codeClass.Name);
}
public TypeCache ByName(CodeClass2 cc)
{
if (!(ByNameCache.ContainsKey(cc.FullName)))
{
var tc = new TypeCache(cc.FullName);
ByNameCache.Add(cc.FullName, tc);
ByTypeCache.Add(tc.TypeInfo.AsType(), tc);
}
return(ByNameCache[cc.FullName]);
}
public void GetEnumerator_OneClassCompletionEntryInNamespace_ReturnsOneCodeClass()
{
helper.AddClassToProjectContentAndCompletionEntries("Test", "Test.MyClass");
CreateCodeElements("Test");
CodeClass2 codeClass = codeElements.ToList().FirstOrDefault() as CodeClass2;
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("MyClass", codeClass.Name);
Assert.AreEqual("Test.MyClass", codeClass.FullName);
}
public static void AddInterfaceIfNotExists(this CodeClass2 cls, string interfaceName)
{
try {
if (!(cls.ImplementedInterfaces.OfType <CodeInterface>().Any(x => x.FullName == interfaceName)))
{
cls.AddImplementedInterface(interfaceName);
}
}
catch (Exception e) {
MessageBox.Show("The added interface has to exists in the project." + e);
}
}
public void BaseTypes_ClassBaseTypeIsSystemObject_ReturnsSystemObject()
{
CreateClass("public class MyClass {}");
global::EnvDTE.CodeElements codeElements = codeClass.Bases;
CodeClass2 baseClass = codeElements.FirstCodeClass2OrDefault();
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("System.Object", baseClass.FullName);
Assert.AreEqual("Object", baseClass.Name);
}
public void Members_NamespaceHasOneClass_ReturnsOneClass()
{
CreateProjectContent();
AddClassToProjectContent("Tests", "Tests.MyClass");
CreateCodeNamespace("Tests");
global::EnvDTE.CodeElements members = codeNamespace.Members;
CodeClass2 codeClass = members.FirstCodeClass2OrDefault();
Assert.AreEqual(1, members.Count);
Assert.AreEqual("Tests.MyClass", codeClass.FullName);
}
public void CodeElements_OneClassInFileWithNamespace_ReturnsOneClassInsideCodeNamespace()
{
CreateProjectWithOneFile();
CreateCompilationUnitForFileProjectItem();
AddClassToCompilationUnit("Test.CodeModel", "Test.CodeModel.Class1");
CreateFileCodeModel();
CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements();
CodeClass2 codeClass = ns.Members.FirstCodeClass2OrDefault();
Assert.AreEqual("Test.CodeModel.Class1", codeClass.FullName);
}
/// <summary>
/// Get Bases recursively
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public static IEnumerable <CodeClass2> GetAncestorClasses(this CodeClass2 cc)
{
var bases = cc.Bases.OfType <CodeClass2>().ToArray();
if (bases.FirstOrDefault() == null)
{
return(bases);
}
var grandBases = bases.SelectMany(x => x.GetAncestorClasses());
return(bases.Concat(grandBases));
}
/// <summary>
/// Returns a list of classes (which have subclasses) within the same namespace of cls
/// </summary>
/// <param name="cls"></param>
/// <remarks> using <see cref="CodeClass2.IsDerivedFrom"/> because <see cref="CodeClass2.DerivedTypes"/> is not implemented in C#
/// </remarks>
/// <returns></returns>
private CodeClass2[] GetBaseclassesFromSameNamespace(CodeClass2 cls)
{
var classes = new List<CodeClass2>();
_projectItem.Project
.TraverseHierarchyForCodeElements<CodeClass2>(
classes.Add,
x => x.Namespace.FullName == cls.Namespace.FullName && cls != x);
//select classes which have subclasses.
var baseClasses = classes.Where(
baseC => classes.Any(derived =>
derived.IsDerivedFrom[baseC.FullName]
// skip self, IsDerivedFrom returns true on itself
&& baseC != derived));
return baseClasses.ToArray();
}
public static void Excute(CodeClass2 classElement, Dictionary<string, CodeClass2> dic, TyrantVSPackage package)
{
if (classElement == null)
return;
string callBackGenericParamaName = null;
foreach (CodeElement baseClass in classElement.Bases)
{
string baseFullName = baseClass.FullName;
if (baseFullName.StartsWith("Tyrant.GameCore.Message<"))
{
Stack<int> ind = new Stack<int>();
int thirdGenericParama = -1, find = 0;
int first = baseFullName.IndexOf('<');
for (int i = first + 1; i < baseFullName.Length; ++i)
{
char c = baseFullName[i];
if (c == '<')
ind.Push(i);
else if (c == ',')
{
if (ind.Count <= 0)
{
++find;
if (find == 2)
thirdGenericParama = i + 1;
}
}
else if (c == '>')
{
if (ind.Count > 0)
ind.Pop();
else
{
if (thirdGenericParama > 0 && thirdGenericParama < baseFullName.Length)
callBackGenericParamaName = baseFullName.Substring(thirdGenericParama, i - 1 - thirdGenericParama).Trim();
break;
}
}
}
}
}
var validInterfaces = new List<CodeElement>();
foreach (CodeElement implementedInterface in classElement.ImplementedInterfaces)
{
if (implementedInterface.FullName != "Tyrant.GameCore.ISerializable")
{
validInterfaces.Add(implementedInterface);
break;
}
}
var name = classElement.Name;
var fullName = classElement.FullName;
var collection = classElement.Collection;
if (!string.IsNullOrEmpty(callBackGenericParamaName))
{
int first = callBackGenericParamaName.IndexOf('<');
if (first >= 0)
callBackGenericParamaName = callBackGenericParamaName.Substring(0, first);
callBackGenericParamaName = $", {callBackGenericParamaName}<TUser>";
}
else
callBackGenericParamaName = "";
classElement.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint().ReplaceText(classElement.GetStartPoint(vsCMPart.vsCMPartBody), $"public partial class {name}<TUser> : Tyrant.GameCore.Message<TUser, {name}<TUser>{callBackGenericParamaName}> where TUser : Tyrant.GameCore.IUser{Environment.NewLine}{{{Environment.NewLine}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
classElement = collection.Item(name) as CodeClass2;
foreach (CodeElement implementedInterface in validInterfaces)
{
try
{
classElement.AddImplementedInterface(implementedInterface, -1);
}
catch { }
}
CommunicationCodeHelper.RemoveMembers(classElement);
CodeFunction2 serializeMethod = null, deserializeMethod = null;
try
{
classElement.AddFunction("Serialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessProtected);
}
catch { }
serializeMethod = classElement.Members.Item("Serialize") as CodeFunction2;
if (serializeMethod == null)
{
return;
}
serializeMethod.OverrideKind = vsCMOverrideKind.vsCMOverrideKindOverride;
try
{
serializeMethod.AddParameter("dest", typeof(ProtoBuf.ProtoWriter).FullName);
}
catch
{
serializeMethod = classElement.Members.Item("Serialize") as CodeFunction2;
}
try
{
classElement.AddFunction("Deserialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessProtected);
}
catch { }
deserializeMethod = classElement.Members.Item("Deserialize") as CodeFunction2;
if (deserializeMethod == null)
{
return;
}
deserializeMethod.OverrideKind = vsCMOverrideKind.vsCMOverrideKindOverride;
try
{
deserializeMethod.AddParameter("source", typeof(ProtoBuf.ProtoReader).FullName);
}
catch
{
deserializeMethod = classElement.Members.Item("Deserialize") as CodeFunction2;
}
CommunicationCodeHelper.GenerateSerializaCode(classElement, serializeMethod, deserializeMethod, dic, package/*, "dest", "source"*/);
}
internal ShellCodeClass(CodeClass2 codeClass) : base(codeClass as CodeElement2)
{
_codeClass = codeClass;
}
public static void Excute(CodeClass2 classElement, Dictionary<string, CodeClass2> dic, TyrantVSPackage package)
{
if (classElement == null)
return;
//var classCode = classElement.StartPoint.CreateEditPoint().GetText(classElement.GetEndPoint());
var validBases = new List<CodeElement>();
foreach (CodeElement baseClass in classElement.Bases)
{
if (!baseClass.FullName.StartsWith("Tyrant.GameCore.Message<") && baseClass.FullName != typeof(object).FullName)
validBases.Add(baseClass);
}
var validInterfaces = new List<CodeElement>();
foreach (CodeElement implementedInterface in classElement.ImplementedInterfaces)
{
if (implementedInterface.FullName != "Tyrant.GameCore.ISerializable")
{
validInterfaces.Add(implementedInterface);
break;
}
}
var baseCollection = classElement.Collection;
string name = classElement.Name;
classElement.GetStartPoint(vsCMPart.vsCMPartHeader).CreateEditPoint().ReplaceText(classElement.GetStartPoint(vsCMPart.vsCMPartBody), $"public partial class {name}{Environment.NewLine}{{{Environment.NewLine}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
classElement = baseCollection.Item(name) as CodeClass2;
classElement.AddImplementedInterface("Tyrant.GameCore.ISerializable");
foreach (CodeElement baseClass in validBases)
{
try
{
classElement.AddBase(baseClass, -1);
}
catch { }
}
foreach (CodeElement implementedInterface in validInterfaces)
{
try
{
classElement.AddImplementedInterface(implementedInterface, -1);
}
catch { }
}
CommunicationCodeHelper.RemoveMembers(classElement);
CodeFunction2 serializeMethod = null, deserializeMethod = null;
try
{
classElement.AddFunction("Tyrant.GameCore.ISerializable.Serialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessDefault);
}
catch { }
serializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Serialize") as CodeFunction2;
try
{
serializeMethod.AddParameter("dest", typeof(ProtoBuf.ProtoWriter).FullName);
}
catch
{
serializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Serialize") as CodeFunction2;
}
try
{
classElement.AddFunction("Tyrant.GameCore.ISerializable.Deserialize", vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid, -1, vsCMAccess.vsCMAccessDefault);
}
catch { }
deserializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Deserialize") as CodeFunction2;
try
{
deserializeMethod.AddParameter("source", typeof(ProtoBuf.ProtoReader).FullName);
}
catch
{
deserializeMethod = classElement.Members.Item("Tyrant.GameCore.ISerializable.Deserialize") as CodeFunction2;
}
CommunicationCodeHelper.GenerateSerializaCode(classElement, serializeMethod, deserializeMethod, dic, package/*, "dest", "source"*/);
}
private DbsetCandidate[] GetCandidateList(CodeClass2 selectedBase)
{
try {
var descendants = new List<CodeClass2>();
_projectItem.Project.TraverseHierarchyForCodeElements<CodeClass2>(descendants.Add,
x => x != selectedBase
&& x.IsDerivedFrom[selectedBase.FullName]);
var pluralizationService = new EnglishPluralizationService();
var items = from c in descendants
select
new DbsetCandidate() {
Class = c,
IsAlreadyDefined = _existingSets.Contains(c.FullName),
SetName = pluralizationService.Pluralize(c.Name)
};
return items.ToArray();;
}
catch (Exception e) {
Debug.DebugHere(e);
throw;
}
}
private void WriteGetbytypeMethod(CodeClass2 cls)
{
var sets = GetExistingSets(cls);
var code = General.GetTemplateOutput(output => GenGetbytype(output, sets));
var insertPoint = cls.GetStartPoint(vsCMPart.vsCMPartBody);
var manager = new Manager<DbSet, GeneratorOptionAttribute>(TagFormat.Json);
var writer = manager.CreateWriter(cls);
writer.OptionTag.Trigger.Type = TriggerTypes.CodeSnippet;
writer.InsertStart = insertPoint;
writer.TargetRange = new TaggedRange() {StartPoint = cls.StartPoint, EndPoint = cls.EndPoint};
writer.Content = code;
writer.TagNote = "GetDbsetByType";
writer.InsertOrReplace(true);
}
public NotifyPropertyChanged_GenAttribute(CodeClass2 cc)
: base(cc)
{
Init();
}
public CodeClassNodeFactory(CodeClass2 element) : base(element as CodeElement)
{
_codeClass = element;
}
private IEnumerable<CodeClass2> GetClassesFromSameNamespace(CodeClass2 cls)
{
var classes = new List<CodeClass2>();
ProjectItem.Project.TraverseCodeElements<CodeClass2>(classes.Add, x => x.Namespace.FullName == cls.Namespace.FullName && cls != x); ;//cls.Namespace.Children.OfType<CodeClass2>();
return classes.ToArray();
}
public void WritePropertyNames(CodeClass2 cls)
{
var props = cls.GetProperties().Select(p => p.ToPropertyInfo()).ToArray();
var output = new System.IO.StringWriter();
GenEnum(output, props, true);
var writer = Manager.CreateWriter() ;
writer.Class = cls;
writer.SegmentType = SegmentTypes.Region;
writer.SearchStart = cls.StartPoint;
writer.SearchEnd = cls.EndPoint;
writer.OptionTag = new ManagerType.OptionTag() { Version = Version, RegenMode = RegenModes.Always, Trigger = new TriggerInfo( TriggerTypes.CodeSnippet)};
writer.Content = output.ToString();
writer.InsertStart =cls.GetStartPoint(vsCMPart.vsCMPartBody);
writer.InsertOrReplace();
}
private CodeDomClassMetadata(CodeClass2 codeClass, CodeDomFileMetadata file)
{
this.codeClass = codeClass;
this.file = file;
}
public TypeCache ByName(CodeClass2 cc)
{
if (!(ByNameCache.ContainsKey(cc.FullName)))
{
var tc = new TypeCache(cc.FullName);
ByNameCache.Add(cc.FullName, tc);
ByTypeCache.Add(tc.TypeInfo.AsType(), tc);
}
return ByNameCache[cc.FullName];
}
private static string[] GetExistingSetNames(CodeClass2 cls)
{
return GetExistingSets(cls).
Select(p => GetDbsetGenericParameter(p.Type)).ToArray();
}
internal static void RemoveMembers(CodeClass2 classElement)
{
var methodToDelete = new List<CodeElement2>();
foreach (CodeElement2 member in classElement.Members)
{
CodeFunction2 method = member as CodeFunction2;
if (method == null)
continue;
var strs = method.Name.Split('.');
if (strs.Length >= 2 && strs[strs.Length - 2].Trim() == "ISerializable")
{
if (strs[strs.Length - 1].Trim() == "Serialize" || strs[strs.Length - 1].Trim() == "Deserialize")
methodToDelete.Add(member);
}
else if (method.Name == "Serialize" || method.Name == "Deserialize")
methodToDelete.Add(member);
}
foreach (CodeElement2 method in methodToDelete)
classElement.RemoveMember(method);
}
private void WriteDbset(CodeClass2 targetContext, IEnumerable<DbsetCandidate> selections)
{
var code =General.GetTemplateOutput(output => GenDbset(output,selections));
var insertPoint =targetContext.GetStartPoint(vsCMPart.vsCMPartBody);
insertPoint.InsertAndFormat(code);
}
internal static bool IsMessageClass(CodeClass2 codeClass)
{
if (codeClass != null)
{
foreach (CodeElement2 baseClass in codeClass.Bases)
{
if (baseClass.FullName.StartsWith("Tyrant.GameCore.Message<"))
return true;
}
}
return false;
}
/// <summary>
///
/// </summary>
public virtual bool AcceptClass(CodeClass2 c)
{
return true;
}
public CommandActionInternal(MetaCommand metaCommand, CodeClass2 mcclass)
{
_metaCommand = metaCommand;
_mcclass = mcclass;
foreach (CodeAttribute2 attr in mcclass.Attributes)
{
if (attr.FullName == typeof(WhenFileChangedAttribute).FullName)
{
_eventType = EventType.FileChanged;
var attrParameters = attr.Arguments.Cast<CodeAttributeArgument>().Select(_ => _.Value.Trim('\"')).ToArray();
_fileChangedMasks.Add(new FileChangedArgument(attrParameters[0], attrParameters[1], true));
DTEHelper.Events.Subscribe(_eventType, _metaCommand);
}
}
}
/// <summary>
///
/// </summary>
/// <returns>Array of invalid properties</returns>
/// <remarks></remarks>
public string[] ValidateExtraNotifications(CodeClass2 cc, string[] extras)
{
var propNames = new HashSet<string>(cc.GetProperties().Select((x) => x.Name));
var invalids = extras.Where((x) => !(propNames.Contains(x))).ToArray();
if (invalids.Any()) {
return invalids;
}
ExtraNotifications = string.Join(", ", extras);
return new string[0]; //return empty array
}
/// <summary>
///
/// </summary>
public static List<AttributeInfo> GetAttributes(CodeClass2 type)
{
var l = new List<AttributeInfo>();
while (type != null)
{
var attribute = GetAttributes(type.Attributes);
l.AddRange(attribute);
if (type.Bases.Count == 0)
return null;
type = (CodeClass2)type.Bases.Item(1);
}
return l;
}
//internal static bool IsNormalMessage(CodeElement2 CodeElement)
//{
//}
//internal static bool IsCallBackMessage(CodeElement2 CodeElement)
//{
//}
internal static bool IsSerializableClass(CodeClass2 codeClass)
{
if (codeClass != null)
{
foreach (CodeElement2 implementedInterface in codeClass.ImplementedInterfaces)
{
if (implementedInterface.FullName == "Tyrant.GameCore.ISerializable")
return true;
}
}
return false;
}
internal static IClassMetadata FromCodeClass(CodeClass2 codeClass, CodeDomFileMetadata file)
{
return codeClass == null ? null : new CodeDomClassMetadata(codeClass, file);
}
internal static void GenerateSerializaCode(CodeClass2 classElement, CodeFunction serializeMethod, CodeFunction deserializeMethod, Dictionary<string, CodeClass2> dic, TyrantVSPackage package/*, string serializeMethodParameterName, string deserializeMethodParameterName*/)
{
var memberList = new List<SerializeMember>();
foreach (CodeElement2 member in classElement.Members)
{
var field = member as CodeVariable2;
if (field != null)
{
memberList.Add(new SerializeMember() { Name = field.Name, TypeRef = field.Type, Attributes = field.Attributes });
continue;
}
var property = member as CodeProperty2;
if (property != null && property.Getter != null && property.Setter != null)
memberList.Add(new SerializeMember() { Name = property.Name, TypeRef = property.Type, Attributes = property.Attributes });
}
int iii = serializeMethod.Parameters.Count;
string serializeMethodParameterName = serializeMethod.Parameters.Item(1).Name;
string deserializeMethodParameterName = deserializeMethod.Parameters.Item(1).Name;
var serializeStatementList = new List<string>();
var deserializeStatementList = new List<string>();
string deserializeMethodCode = string.Format("int num;{0}while ((num = source.ReadFieldHeader()) > 0){0}{1}{0}switch (num){0}{1}{0}", Environment.NewLine, "{");
for (int i = 0; i < memberList.Count; ++i)
{
var mem = memberList[i];
bool needContinue = false;
foreach (CodeAttribute2 codeArrtibute in mem.Attributes)
{
if (codeArrtibute.FullName == "Tyrant.GameCore.DoNotSerializeAttribute")
{
needContinue = true;
break;
}
}
if (needContinue)
continue;
string serializeMethodName = "";
string deserializeMethodName = "";
if (mem.TypeRef.TypeKind == vsCMTypeRef.vsCMTypeRefArray)
GetSerializeMethodAndDeserializeMethodName(mem.TypeRef.ElementType, null, ref serializeMethodName, ref deserializeMethodName, "Array", dic, package);
else
{
if (mem.TypeRef.AsFullName.StartsWith("System.Collections.Generic.List<"))
{
string fullName = mem.TypeRef.AsFullName;
int first = fullName.IndexOf('<');
var elementName = fullName.Substring(first + 1, fullName.Length - 2 - first);
GetSerializeMethodAndDeserializeMethodName(null, elementName, ref serializeMethodName, ref deserializeMethodName, "List", dic, package);
}
else
GetSerializeMethodAndDeserializeMethodName(mem.TypeRef, null, ref serializeMethodName, ref deserializeMethodName);
}
serializeStatementList.Add($"Tyrant.GameCore.CommunicatorHelper.{serializeMethodName}({i + 1}, {mem.Name}, {serializeMethodParameterName});");
deserializeStatementList.Add($"case {i + 1}:{Environment.NewLine}{mem.Name} = Tyrant.GameCore.CommunicatorHelper.{deserializeMethodName}({deserializeMethodParameterName});{Environment.NewLine}break;");
}
if (serializeStatementList.Count > 0)
{
var point = serializeMethod.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
point.ReplaceText(serializeMethod.GetEndPoint(vsCMPart.vsCMPartBody), string.Join(Environment.NewLine, serializeStatementList), (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
}
if (deserializeStatementList.Count > 0)
{
var point = deserializeMethod.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint();
point.ReplaceText(deserializeMethod.GetEndPoint(vsCMPart.vsCMPartBody), deserializeMethodCode + string.Join(Environment.NewLine, deserializeStatementList) + Environment.NewLine + "}" + Environment.NewLine + "}", (int)vsEPReplaceTextOptions.vsEPReplaceTextAutoformat);
}
}
public MetaCommand(CodeClass2 mcclass)
: this(mcclass.FullName)
{
CommandAction = new CommandActionInternal(this, mcclass);
ProjectName = mcclass.ProjectItem.ContainingProject.Name;
}
internal static IClassMetadata FromCodeClass(CodeClass2 codeClass, CodeDomFileMetadata file)
{
return codeClass == null || codeClass.Access != vsCMAccess.vsCMAccessPublic || codeClass.FullName == "System.Object" ? null : new CodeDomClassMetadata(codeClass, file);
}
/// <summary>
///
/// </summary>
public virtual ClassInfo CreateClass(NodeItem parent, CodeClass2 item)
{
return new ClassInfo(parent, item);
}
