public object ExecuteNewAssembly(byte[] rawAssm, object param)
{
Assembly asm = Assembly.Load(rawAssm);
CodeInterface assemblyObj = null;
foreach (Type t in asm.GetTypes())
{
if (t.GetInterface("CodeInterface") != null)
{
assemblyObj = (CodeInterface)Activator.CreateInstance(t);
}
}
object output = string.Empty;
try
{
output = assemblyObj.DoWork(param);
}
catch (Exception ex)
{
output = ex.Message;
}
return(output);
}
public override bool CanExecute(IDictionary<string, object> parameter)
{
_document = _dte.ActiveDocument;
if (_document == null || _document.ProjectItem == null || _document.ProjectItem.FileCodeModel == null)
{
MessageBox(ErrMessage);
return false;
}
_serviceClass = GetClass(_document.ProjectItem.FileCodeModel.CodeElements);
if (_serviceClass == null)
{
MessageBox(ErrMessage);
return false;
}
_serviceInterface = GetServiceInterface(_serviceClass as CodeElement);
if (_serviceInterface == null)
{
MessageBox(ErrMessage);
return false;
}
_serviceName = _serviceClass.Name.Replace("AppService", "");
return true;
}
/// <summary>
/// Finds the function interface element.
/// </summary>
/// <param name="cc">The cc.</param>
/// <param name="functionName">Name of the function.</param>
/// <param name="arguments">The arguments.</param>
/// <returns></returns>
internal static CodeFunction2 FindFunctionInterfaceElement(CodeInterface cc, string functionName,
List <Argument> arguments)
{
foreach (CodeElement ce in cc.Members)
{
if (ce is CodeFunction2 && functionName == ce.Name)
{
CodeFunction2 cf = ce as CodeFunction2;
if (cf.Parameters.Count == arguments.Count)
{
// On regarde si les paramètres correspondent
for (int i = 0; i < arguments.Count; i++)
{
CodeParameter param = (CodeParameter)cf.Parameters.Item(i + 1);
if (param.Name != arguments[i].Name)
{
return(null);
}
}
return(cf);
}
}
}
return(null);
}
public bool AddInterface(string intName, string intNotes, string intType, ref CodeInterface intObj)
{
Project prjObj = null;
if (!prjCreate(intType, ref prjObj))
{
return(false);
}
prjObj.ProjectItems.AddFromTemplate("C:\\Program Files\\Microsoft Visual Studio .NET\\VC#\\CSharpProjectItems\\NewCSharpFile.cs", intName + ".cs");
ProjectItem pi = prjObj.ProjectItems.Item(intName + ".cs");
CodeNamespace cn = pi.FileCodeModel.AddNamespace(intType, 0);
TextPoint tp = cn.GetStartPoint(EnvDTE.vsCMPart.vsCMPartHeader);
EditPoint ep = tp.CreateEditPoint();
ep.StartOfDocument();
ep.Insert("using System;\n");
CodeInterface ci = cn.AddInterface(intName, 0, null, EnvDTE.vsCMAccess.vsCMAccessPublic);
ci.Comment = intNotes;
appOb.Solution.SolutionBuild.Build(false);
intObj = ci;
return(true);
}
void CreateInterface(string code, string fileName = @"c:\projects\MyProject\interface.cs")
{
CreateCodeModel();
AddCodeFile(fileName, code);
interfaceTypeDefinition = assemblyModel.TopLevelTypeDefinitions.First().Resolve();
codeInterface = new CodeInterface(codeModelContext, interfaceTypeDefinition);
}
/// <summary>
/// Finds the interface element for given <see cref="CodeElements"/> instance
/// </summary>
/// <param name="elements"></param>
/// <returns></returns>
public static CodeInterface FindInterface(this CodeElements elements)
{
// Loop
foreach (CodeElement element in elements)
{
// Get element as interface
CodeInterface myInterface = element as CodeInterface;
// if it is interface then return
if (myInterface != null)
{
return(myInterface);
}
// Or recurse the clidren
myInterface = FindInterface(element.Children);
// if found return
if (myInterface != null)
{
return(myInterface);
}
}
// Oppss. We didnt find it
return(null);
}
/// <summary>
/// Creates the interface.
/// </summary>
/// <param name="instance">The instance.</param>
/// <returns>The interface.</returns>
public static CodeInterface CreateInterface(this ProjectItem instance)
{
string interfaceName = string.Format("I{0}", instance.Name);
string path = instance.FileNames[1].Replace(instance.Name, interfaceName);
CodeNamespace codeNamespace = instance.GetNameSpace();
string nameSpace = codeNamespace.FullName;
object[] bases = { };
CodeNamespace interfaceNameSpace = instance.ProjectItems.ContainingProject.CodeModel.AddNamespace(
nameSpace, path);
CodeInterface codeInterface = interfaceNameSpace.AddInterface(
interfaceName, -1, bases, vsCMAccess.vsCMAccessPublic);
CodeClass codeClass = instance.GetFirstClass();
if (codeClass != null)
{
object interfaceClass = interfaceName;
codeClass.AddImplementedInterface(interfaceClass, 0);
}
return(codeInterface);
}
void CreateInterface(string code)
{
AddCodeFile("interface.cs", code);
ITypeDefinition typeDefinition = assemblyModel.TopLevelTypeDefinitions.First().Resolve();
codeInterface = new CodeInterface(codeModelContext, typeDefinition);
}
/// <summary>
/// Gets the declaration of the specified code interface as a string.
/// </summary>
/// <param name="codeInterface">The code interface.</param>
/// <returns>The string declaration.</returns>
internal static string GetInterfaceDeclaration(CodeInterface codeInterface)
{
// Get the start point after the attributes.
var startPoint = codeInterface.GetStartPoint(vsCMPart.vsCMPartHeader);
return(TextDocumentHelper.GetTextToFirstMatch(startPoint, @"\{"));
}
public TypeScriptInterface Build(
CodeInterface codeInterface,
TypeContext typeContext)
{
TypeScriptInterface result = null;
string moduleName = this.settings.GetModuleNameFromNamespace(codeInterface.Namespace);
bool interfaceCreated;
result = typeContext.GetOrCreateInterface(
moduleName,
TypeName.ParseDte(codeInterface.FullName),
codeInterface.Name,
out interfaceCreated);
result.IsClass = this.settings.CreateClasses;
this.PopulateBases(
codeInterface.Bases,
result,
typeContext);
this.PopulateMembers(
codeInterface.Members,
result,
typeContext);
return(result);
}
private void Interfaces(CodeElement codeElement)
{
CodeElements ces = null;
if (codeElement is CodeClass)
{
ces = (codeElement as CodeClass).ImplementedInterfaces;
}
else if (codeElement is CodeInterface)
{
ces = (codeElement as CodeInterface).Bases;
}
else
{
return;
}
foreach (CodeElement ce in ces)
{
CodeInterface codeInterface = ce as CodeInterface;
if (codeInterface.Name != null)
{
string i = string.Format(interfaceInheritanceExpression, codeInterface.Name, codeElement.Name);
AppendExpression(i);
}
}
}
private static string getInterfaceName(CodeInterface @interface)
{
var parents = GetParents(@interface);
var nspace = GetNameSpaceName(@interface.Namespace);
return(nspace + "." + parents);
}
protected string ObjectToClassName(object baseCls)
{
string strBase = baseCls as string;
if (strBase != null)
{
return(strBase);
}
CodeClass cs = baseCls as CodeClass;
if (cs != null)
{
return(cs.FullName);
}
CodeInterface ci = baseCls as CodeInterface;
if (ci != null)
{
return(ci.FullName);
}
return(ObjectToTypeRef(baseCls).AsFullName);
}
private void AddMethodToInterface(CodeInterface serviceInterface, string name, bool async)
{
string parameter = string.Format("{0}Input", name);
var returnName = string.Format(async ? "Task<{0}Output>" : "{0}Output", name);
var function = serviceInterface.AddFunction(name, vsCMFunction.vsCMFunctionFunction, returnName, -1);
function.AddParameter("input", parameter);
}
/// <summary>
/// 生成方法定义到接口
/// </summary>
/// <param name="serviceInterface"></param>
/// <param name="name"></param>
/// <param name="async"></param>
private void AddMethodToInterface(CodeInterface serviceInterface, string methodName, string doccoment, bool async)
{
var returnName = string.Format(async ? "Task<{0}>" : "{0}", GetDtoClassName(methodName, DtoType.Output));
var function = serviceInterface.AddFunction(methodName, vsCMFunction.vsCMFunctionFunction, returnName, -1);
function.AddParameter("input", GetDtoClassName(methodName, DtoType.Input));
function.Comment = doccoment;
}
public InterfaceNode(CodeInterface ci, CodeModelEditorForm context)
: base(CodeModelEditor.BrowseKind.Interface, context)
{
base.Tag = ci;
base.ImageKey = "Interface";
base.SelectedImageKey = "Interface";
SetText(ci.Name);
}
private void AddMethodToInterface(CodeInterface serviceInterface, string name, bool async)
{
_statusBar.Progress(true, $"Generating service interface: {name}...", _steps++, _totalSteps);
string parameter = $"{name}Input";
var returnName = string.Format(async ? "Task<{0}Output>" : "{0}Output", name);
var function = serviceInterface.AddFunction(name, vsCMFunction.vsCMFunctionFunction, returnName, -1);
function.AddParameter("input", parameter);
}
public void Item_OneInterfaceCompletionEntryAndItemSelectedByName_ReturnsOneCodeInterface()
{
helper.AddInterfaceToProjectContentAndCompletionEntries("Test", "Test.IClass");
CreateCodeElements("Test");
CodeInterface codeInterface = codeElements.Item("IClass") as CodeInterface;
Assert.AreEqual("Test.IClass", codeInterface.FullName);
}
public bool ImpInterface(string intType, Project intPrj, CodeInterface intObj, ref CodeClass intCla)
{
Project prjObj = null;
if (!prjCreate(intType, ref prjObj))
{
return(false);
}
// add the necessary references
VSProject vsPrj = (VSProject)prjObj.Object;
Reference vsref = vsPrj.References.AddProject(intPrj);
string claName;
claName = intObj.Name;
CodeInterface[] Ints = new CodeInterface[1];
Ints[0] = intObj;
prjObj.ProjectItems.AddFromTemplate("C:\\Program Files\\Microsoft Visual Studio .NET\\VC#\\CSharpProjectItems\\NewCSharpFile.cs", claName + ".cs");
ProjectItem pi = prjObj.ProjectItems.Item(claName + ".cs");
CodeNamespace cn = pi.FileCodeModel.AddNamespace(intType, 0);
TextPoint tp = cn.GetStartPoint(EnvDTE.vsCMPart.vsCMPartHeader);
EditPoint ep = tp.CreateEditPoint();
ep.StartOfDocument();
ep.Insert("using " + intObj.Namespace.FullName + ";\n");
CodeClass cc = cn.AddClass(intObj.Name, 0, null, null, EnvDTE.vsCMAccess.vsCMAccessPublic);
tp = cc.GetStartPoint(EnvDTE.vsCMPart.vsCMPartName);
ep = tp.CreateEditPoint();
ep.EndOfLine();
ep.Insert(" : " + intObj.FullName);
cc.Comment = intObj.Comment;
foreach (CodeElement ce in intObj.Members)
{
if (ce.Kind == EnvDTE.vsCMElement.vsCMElementFunction)
{
CodeFunction cf = (CodeFunction)ce;
CodeFunction cf1 = cc.AddFunction(cf.Name, cf.FunctionKind, cf.Type, 0, cf.Access, 0);
CodeParameter cep1 = null;
foreach (CodeElement cep in cf.Parameters)
{
CodeParameter cp = (CodeParameter)cep;
cep1 = cf1.AddParameter(cp.Name, cp.Type, -1);
}
}
}
intCla = cc;
return(true);
}
private static string GetNamespace(CodeInterface cc)
{
if (!Options.UseNamespace)
{
return(Options.DefaultModuleName);
}
return(cc == null
? Options.DefaultModuleName
: cc.Namespace.FullName);
}
public CodeInterface AddInterface(string Name, object Position, object Bases, vsCMAccess Access)
{
Initialize();
InitTopNamespace();
CodeInterface ci = vsTopNamespace.AddInterface(Name, Position, Bases, Access);
CommitChanges();
return(ci);
}
public static void AddIfNotExists(this List <CodeInterface> lst, CodeInterface codeInterface)
{
if (codeInterface == null || codeInterface.Name == null || lst == null)
{
return;
}
if (lst.Any(x => x.FullName == codeInterface.FullName))
{
return;
}
lst.Add(codeInterface);
}
public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection()
{
CreateProjectContent();
CreatePublicClass("MyClass");
AddInterfaceToClassBaseTypes("System.Collections.Generic.ICollection", "System.Collections.Generic.ICollection{System.String}");
CodeElements codeElements = codeClass.ImplementedInterfaces;
CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
}
public CodeInterfaceDeclarationWriterTests()
{
codeElementWriter = new CodeInterfaceDeclarationWriter(new GoConventionService());
writer = LanguageWriter.GetLanguageWriter(GenerationLanguage.Go, DefaultPath, DefaultName);
tw = new StringWriter();
writer.SetTextWriter(tw);
root = CodeNamespace.InitRootNamespace();
parentInterface = new () {
Name = "parentClass"
};
root.AddInterface(parentInterface);
}
private void BeforeExpand(TreeNode parentNode, CodeInterface codeInterface)
{
InterfaceNode cn = new InterfaceNode(codeInterface, this);
if (codeInterface.Members.Count > 0)
{
AddNodeWithChilds(parentNode.Nodes, cn);
}
else
{
parentNode.Nodes.Add(cn);
}
}
public void ImplementedInterfaces_ClassImplementsIDisposable_ReturnsCodeInterfaceForIDisposable()
{
CreateClass(
"using System;\r\n" +
"class MyClass : IDisposable {}");
global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("System.IDisposable", codeInterface.FullName);
}
public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection()
{
CreateClass(
"using System;\r\n" +
"using System.Collections.Generic;\r\n" +
"class MyClass : ICollection<string> {}");
global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
}
private bool IsFoundInInterface(CodeFunction function, CodeInterface codeInterface)
{
foreach (CodeElement destFunc in codeInterface.Children)
{
if (destFunc.Kind == vsCMElement.vsCMElementFunction)
{
if (function.Name == destFunc.Name && ContainSameParameters(function, (CodeFunction)destFunc))
{
return(true);
}
}
}
return(false);
}
private void FillAllBaseInterfaces(List <CodeInterface> list, CodeInterface codeInterface)
{
if (IsPartOfTheSolution((CodeElement)codeInterface))
{
list.Add(codeInterface);
}
foreach (CodeElement item in codeInterface.Bases)
{
if (item.Kind == vsCMElement.vsCMElementInterface)
{
FillAllBaseInterfaces(list, (CodeInterface)item);
}
}
}
private static IEnumerable<CodeInterface> GetImplementedInterfacesRecursivly(CodeInterface currentInterface)
{
if (currentInterface != null)
{
var interfaces = new List<CodeInterface> { currentInterface };
foreach (var baseElement in currentInterface.Bases)
{
if (baseElement is CodeInterface)
{
interfaces.AddRange(GetImplementedInterfacesRecursivly(baseElement as CodeInterface));
}
}
return interfaces;
}
return Enumerable.Empty<CodeInterface>();
}
/// <summary>
/// Determines whether the specified element has attribute.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="attributeName">Name of the attribute.</param>
/// <returns>
/// <c>true</c> if the specified element has attribute; otherwise, <c>false</c>.
/// </returns>
public static bool HasAttribute(CodeInterface element, string attributeName)
{
if (element.Attributes.Count > 0)
{
foreach (CodeElement att in element.Attributes)
{
CodeAttribute codeAttribute = (CodeAttribute)att;
if (att.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
}
}
return(false);
}
private void mnuAddDInterface_Click(object sender, System.EventArgs e)
{
frmAddInterface frmAI = new frmAddInterface();
if (frmAI.ShowDialog() == DialogResult.OK)
{
string intName, intNotes;
intName = frmAI.tbxIntName.Text.Trim().Replace(" ", "_");
intNotes = frmAI.txbNotes.Text.Trim();
CodeInterface ci = null;
sc.AddInterface(intName, intNotes, "Data_Interfaces", ref ci);
TreeNode addTemp = new TreeNode("", 4, 4);
addTemp.Text = intName;
addTemp.Tag = ci;
tv.SelectedNode.Nodes.Add(addTemp);
tv.SelectedNode.ExpandAll();
}
}
private void AddMethodToInterface(CodeInterface serviceInterface, string name, bool async)
{
string parameter = string.Format("{0}Input", _serviceName + name);
var returnName = string.Format(async ? "Task<{0}Output>" : "{0}Output", _serviceName + name);
var function = serviceInterface.AddFunction(name, vsCMFunction.vsCMFunctionFunction, returnName, -1);
function.AddParameter("input", parameter);
}
private static void AddDocCommentToInterface(CodeInterface codeInterface)
{
codeInterface.DocComment = string.Format("The {0}.", codeInterface.Name.CamelCaseSplit()).ToDocComment();
}
/// <summary>
/// Gets the declaration of the specified code interface as a string.
/// </summary>
/// <param name="codeInterface">The code interface.</param>
/// <returns>The string declaration.</returns>
internal static string GetInterfaceDeclaration(CodeInterface codeInterface)
{
// Get the start point after the attributes.
var startPoint = codeInterface.GetStartPoint(vsCMPart.vsCMPartHeader);
return TextDocumentHelper.GetTextToFirstMatch(startPoint, @"\{");
}
protected virtual void VisitInterface(CodeInterface codeInterface)
{
}
/// <summary>
/// Determines whether the specified element has attribute.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="attributeName">Name of the attribute.</param>
/// <returns>
/// <c>true</c> if the specified element has attribute; otherwise, <c>false</c>.
/// </returns>
public static bool HasAttribute(CodeInterface element, string attributeName)
{
if(element.Attributes.Count > 0)
{
foreach(CodeElement att in element.Attributes)
{
CodeAttribute codeAttribute = (CodeAttribute)att;
if(att.Name.Equals(attributeName, StringComparison.InvariantCultureIgnoreCase))
{
return true;
}
}
}
return false;
}
private static string getInterfaceName(CodeInterface @interface)
{
var parents = GetParents(@interface);
var nspace = GetNameSpaceName(@interface.Namespace);
return nspace + "." + parents;
}
public static string GetParents(CodeInterface c)
{
var parent = c.Parent as CodeClass2;
return GetParents((CodeElement2)c, parent);
}
