public static void WalkClass(EnvDTE.CodeClass cls, string indent) { doClass(cls, indent); foreach (EnvDTE.CodeElement codeElem in cls.Bases) { doInheritsFrom(codeElem, indent); } foreach (EnvDTE.CodeElement codeElem in cls.Members) { switch (codeElem.Kind) { case EnvDTE.vsCMElement.vsCMElementVariable: doCodeVariable((CodeVariable)codeElem, indent); break; case EnvDTE.vsCMElement.vsCMElementProperty: doCodeProperty((CodeProperty)codeElem, indent); break; case EnvDTE.vsCMElement.vsCMElementFunction: WalkFunction((CodeFunction)codeElem, indent + "..."); break; default: doCodeElement(codeElem, indent); break; } } }
public void Run(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package) { string className = Microsoft.VisualBasic.Interaction.InputBox("Class name", "Create tests", "VATRate", -1, -1); EnvDTE.ProjectItem f = DTE.ItemOperations.AddNewItem("Visual C# Items\\Code\\Class", className + "RepositoryTests.cs"); EnvDTE.CodeClass c = FirstClass(FirstNamespace(f.FileCodeModel.CodeElements).Children); c.AddFunction("Insert" + className, vsCMFunction.vsCMFunctionFunction, vsCMTypeRef.vsCMTypeRefVoid); }
private CodeTypeDeclaration CodeTypeDeclarationFromCodeClass(EnvDTE.CodeClass vsClass) { // set it up and sink it's handler. CodeTypeDeclaration codeTypeDecl = new CodeTypeDeclaration(vsClass.Name); codeTypeDecl.LinePragma = new CodeLinePragma(this.FileName, vsClass.StartPoint.Line); SetVsElementToCodeObject((CodeElement)vsClass, codeTypeDecl); codeTypeDecl.PopulateMembers += new EventHandler(this.OnTypePopulateMembers); // should this language have an events tab? // we do this so the grid can retrieve this info later... // if (provider.IsVB) { codeTypeDecl.UserData[typeof(System.Windows.Forms.Design.EventsTab)] = "Hide"; // just a marker value } // setup it's modifiers // codeTypeDecl.Attributes = GetMemberAttributesFromVsClass(vsClass); codeTypeDecl.TypeAttributes = TypeAttributes.Class; // check for base types // try { foreach (CodeElement baseElement in vsClass.Bases) { if (baseElement.Kind == vsCMElement.vsCMElementClass) { codeTypeDecl.BaseTypes.Add(new CodeTypeReference(GetUrtTypeFromVsType((EnvDTE.CodeClass)baseElement))); } } } catch (Exception ex) { if (!provider.CodeGenerator.IsValidIdentifier(vsClass.Name)) { throw new Exception(SR.GetString(SR.InvalidClassNameIdentifier)); } throw ex; } return(codeTypeDecl); }
public void Run(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package) { EnvDTE.TextSelection ts = DTE.ActiveWindow.Selection as EnvDTE.TextSelection; if (ts == null) { return; } EnvDTE.CodeClass c = ts.ActivePoint.CodeElement[vsCMElement.vsCMElementClass] as EnvDTE.CodeClass; if (c == null) { return; } foreach (EnvDTE.CodeElement e in c.Members) { if (e.Kind == vsCMElement.vsCMElementFunction) { EnvDTE.TextPoint p = (e as EnvDTE.CodeFunction).GetStartPoint(); DTE.Debugger.Breakpoints.Add("", p.Parent.Parent.FullName, p.Line); } } }
public void test(EnvDTE80.DTE2 DTE, Microsoft.VisualStudio.Shell.Package package) { EnvDTE.TextSelection textSelection = DTE.ActiveWindow.Selection as EnvDTE.TextSelection; if (textSelection == null) { return; } EnvDTE.CodeClass codeClass = textSelection.ActivePoint.CodeElement[vsCMElement.vsCMElementClass] as EnvDTE.CodeClass; if (codeClass == null) { return; } string properties = ""; foreach (CodeElement elem in codeClass.Members) { if (elem.Kind == vsCMElement.vsCMElementProperty) { properties += elem.Name + elem.+ System.Environment.NewLine; } } System.Windows.Clipboard.SetText(properties); }
public abstract void DoCheck(EnvDTE.CodeClass codeClass);
public static void doClass(EnvDTE.CodeClass cls, string indent) { Debug.WriteLine(indent + "class:" + cls.Name); }
//解析接口或类 void parse_body(EnvDTE.CodeClass codeClass) { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); var children = codeClass.Members; foreach (CodeElement codeElement in children) { //解析方法定义,只解析公有方法 if (codeElement.Kind == vsCMElement.vsCMElementFunction) { CodeFunction codeFunction = codeElement as CodeFunction; if (codeFunction.Access == vsCMAccess.vsCMAccessPublic) { CodeFunctionInfo func_info = new CodeFunctionInfo(); //解析返回值 var returnType = codeFunction.Type.AsFullName; func_info.ReturnTypeName = returnType; func_info.IsStatic = codeFunction.IsShared; //解析参数 //string parms = ""; string parms_for_invoke = ""; foreach (CodeParameter param in codeFunction.Parameters) { //TextPoint start = param.GetStartPoint(); //TextPoint finish = param.GetEndPoint(); //parms += start.CreateEditPoint().GetText(finish) + ","; func_info.ParamList.Add(new CodeParamInfo() { Name = param.Name, TypeName = param.Type.AsFullName }); parms_for_invoke += param.Name + ","; } //if (parms.Length > 0) parms = parms.Remove(parms.Length - 1, 1); if (parms_for_invoke.Length > 0) { parms_for_invoke = parms_for_invoke.Remove(parms_for_invoke.Length - 1, 1); } //func_info.ParamString = parms; func_info.InvokeParamString = parms_for_invoke; func_info.ShortName = codeFunction.Name; var tmps = codeFunction.FullName.Split('.'); func_info.Name = tmps[tmps.Length - 1]; if (func_info.Name.IndexOf("<") != -1) { var s = func_info.Name.IndexOf("<") + 1; var l = func_info.Name.Length - s - 1; func_info.GenericTypeArguments = func_info.Name.Substring(s, l).Split(',').Select(it => it.Trim()).ToList(); } if (func_info.ShortName == this.ShortClassName) { CodeConstructorList.Add(func_info); } else if (func_info.ShortName != codeClass.Name) { CodeFunctionList.Add(func_info); } } } ////解析属性定义,只解析公有属性 else if (codeElement.Kind == vsCMElement.vsCMElementProperty) { CodeProperty codeProperty = codeElement as CodeProperty; if (codeProperty.Access == vsCMAccess.vsCMAccessPublic) { CodePropertyInfo property_info = new CodePropertyInfo(); property_info.Name = codeProperty.Name; property_info.TypeName = codeProperty.Type.AsFullName; try { var getter = codeProperty.Getter; property_info.HasGet = getter != null && getter.Access == vsCMAccess.vsCMAccessPublic; property_info.IsStatic = codeProperty.Getter.IsShared; } catch { property_info.HasGet = false; } try { var setter = codeProperty.Setter; property_info.HasSet = setter != null && setter.Access == vsCMAccess.vsCMAccessPublic; property_info.IsStatic = codeProperty.Setter.IsShared; foreach (CodeParameter param in setter.Parameters) { //TextPoint start = param.GetStartPoint(); //TextPoint finish = param.GetEndPoint(); //parms += start.CreateEditPoint().GetText(finish) + ","; property_info.ParamList.Add(new CodeParamInfo() { Name = param.Name, TypeName = param.Type.AsFullName }); } } catch { property_info.HasSet = false; } CodePropertyList.Add(property_info); } } else if (codeElement.Kind == vsCMElement.vsCMElementEvent) { CodeEvent codeEvent = codeElement as CodeEvent; if (codeEvent.Access == vsCMAccess.vsCMAccessPublic) { CodeEventInfo codeEventInfo = new CodeEventInfo(); codeEventInfo.Name = codeEvent.Name; codeEventInfo.TypeName = codeEvent.Type.AsFullName; codeEventInfo.IsStatic = codeEvent.IsShared; CodeEventList.Add(codeEventInfo); } } } foreach (CodeClass baseClass in codeClass.Bases) { if (baseClass.Kind == vsCMElement.vsCMElementClass) { parse_body(baseClass); break; } } }
/// <include file='doc\VsCodeDomParser.uex' path='docs/doc[@for="VsCodeDomParser.OnTypePopulateMembers"]/*' /> /// <devdoc> /// Populate the methods and fields of a class declaration /// </devdoc> private void OnTypePopulateMembers(object sender, EventArgs e) { CodeTypeDeclaration codeTypeDecl = (CodeTypeDeclaration)sender; EnvDTE.CodeClass vsCodeClass = (CodeClass)GetVsElementFromCodeObject(codeTypeDecl); // We create another collection, which we stash in the decl's user // data. This is used to reconcile deletes when we code // gen. // CodeTypeMemberCollection originalMemberCollection = new CodeTypeMemberCollection(); codeTypeDecl.UserData[VsOriginalCollectionKey] = originalMemberCollection; string shortName = codeTypeDecl.Name; int lastDot = shortName.LastIndexOf('.'); if (lastDot != -1) { shortName = shortName.Substring(lastDot + 1); } foreach (CodeElement codeElement in vsCodeClass.Members) { switch (codeElement.Kind) { case vsCMElement.vsCMElementVariable: CodeVariable vsField = (CodeVariable)codeElement; // create the element // CodeMemberField codeField = new CodeMemberField(new CodeTypeReference(GetUrtTypeFromVsType(vsField.Type)), vsField.Name); codeField.LinePragma = new CodeLinePragma(this.FileName, vsField.StartPoint.Line); // get the attributes // codeField.Attributes = GetMemberAttributesFromVsField(vsField); // add it to the members collection SetVsElementToCodeObject((CodeElement)vsField, codeField); codeTypeDecl.Members.Add(codeField); originalMemberCollection.Add(codeField); break; case vsCMElement.vsCMElementFunction: CodeFunction vsFunction = (CodeFunction)codeElement; CodeMemberMethod codeMethod; if (vsFunction.Name == shortName) { codeMethod = new CodeTypeConstructor(); } else { codeMethod = new CodeMemberMethod(); string returnType = GetUrtTypeFromVsType(vsFunction.Type); if (returnType == null || returnType.Length == 0) { returnType = typeof(void).FullName; } codeMethod.ReturnType = new CodeTypeReference(returnType); } // sync up the name with what VS thinks it is. This is important // for things like constructors because the default name from CodeDom is // ".cctor", but VS uses the shortname. // codeMethod.Name = vsFunction.Name; codeMethod.UserData[typeof(EventHandler)] = ehFunctionPointHandler; // add the ref SetVsElementToCodeObject((CodeElement)vsFunction, codeMethod); // setup the attriubutes // codeMethod.Attributes = GetMemberAttributesFromVsFunction(vsFunction); // sink population events. codeMethod.PopulateParameters += new EventHandler(this.OnMethodPopulateParameters); codeMethod.PopulateStatements += new EventHandler(this.OnMethodPopulateStatements); codeTypeDecl.Members.Add(codeMethod); originalMemberCollection.Add(codeMethod); // we'll need to navigate back up on this guy to it's code type. // codeMethod.UserData[typeof(CodeTypeDeclaration)] = codeTypeDecl; // now look for any default event hookups for the object // if (provider.IsVB && codeElement is IEventHandler) { string[] hookups = GetHandlesClauses((IEventHandler)codeElement); Hashtable handlers = (Hashtable)codeTypeDecl.UserData[VbHandlesClausesKey]; // for each handles item like "button1.Click", // push in the handles clause and the function name // foreach (string s in hookups) { if (s != null) { if (handlers == null) { handlers = new Hashtable(); codeTypeDecl.UserData[VbHandlesClausesKey] = handlers; } handlers[s] = codeMethod; } } } break; default: // we really *should* care about the various element types that // the vs codedom is providing, but it turns out vs is // changing those things too often for us to keep up with. // // so i'm removing the individual cases and the assert. we // will just ignore any types we don't directly care about. // case vsCMElement.vsCMElementClass: // case vsCMElement.vsCMElementEvent: // case vsCMElement.vsCMElementProperty: // case vsCMElement.vsCMElementEnum: // case vsCMElement.vsCMElementDelegate: // case vsCMElement.vsCMElementStruct: // case vsCMElement.vsCMElementEventsDeclaration: // default: // Debug.Fail("Unexpected element type '" + codeElement.Kind.ToString() + "' in Type member declaration"); break; } } }