public static void Initialize()
{
if (initialized)
{
return;
}
initialized = true;
projectOptions = new Dictionary <string, CSharpFormattingOptionsPersistence>();
// Load global settings
GlobalOptions = new CSharpFormattingOptionsPersistence(
SD.PropertyService.MainPropertiesContainer, new CSharpFormattingOptionsContainer()
{
DefaultText = StringParser.Parse("${res:CSharpBinding.Formatting.GlobalOptionReference}")
});
GlobalOptions.Load();
// Handlers for solution loading/unloading
var projectService = SD.GetService <IProjectService>();
if (projectService != null)
{
SD.ProjectService.SolutionOpened += SolutionOpened;
SD.ProjectService.SolutionClosed += SolutionClosed;
}
}
void FetchGacContents()
{
IGlobalAssemblyCacheService gacService = SD.GetService <IGlobalAssemblyCacheService>();
HashSet <string> fullNames = new HashSet <string>();
UpdateProgressBar(pg => { pg.Visibility = System.Windows.Visibility.Visible; pg.IsIndeterminate = true; });
var list = gacService.Assemblies.TakeWhile(_ => !cancelFetchThread).ToList();
UpdateProgressBar(pg => { pg.IsIndeterminate = false; pg.Maximum = list.Count; });
foreach (var r in list)
{
if (cancelFetchThread)
{
break;
}
if (fullNames.Add(r.FullName)) // filter duplicates
{
var file = gacService.FindAssemblyInNetGac(r);
if (file != null)
{
var entry = new GacEntry(r, file);
UpdateProgressBar(pg => { pg.Value = pg.Value + 1; AddNewEntry(entry); });
}
}
}
UpdateProgressBar(pg => { pg.Visibility = System.Windows.Visibility.Hidden; });
}
public IAssemblyModel GetAssemblyModel(FileName fileName, bool includeInternalMembers = false)
{
LoadedAssembly assembly = GetLoadedAssembly(fileName, includeInternalMembers);
if (assembly.Model == null)
{
// Get references
DefaultAssemblySearcher assemblySearcher = new DefaultAssemblySearcher(fileName);
var referencedAssemblies = new List <IUnresolvedAssembly>();
foreach (var referencedAssemblyName in assembly.References)
{
var assemblyFileName = assemblySearcher.FindAssembly(referencedAssemblyName);
if (assemblyFileName != null)
{
var loadedRefAssembly = GetLoadedAssembly(assemblyFileName, includeInternalMembers);
if (loadedRefAssembly != null)
{
referencedAssemblies.Add(loadedRefAssembly.ProjectContent);
}
}
}
IEntityModelContext context = new AssemblyEntityModelContext(assembly.ProjectContent, referencedAssemblies.ToArray());
IUpdateableAssemblyModel model = SD.GetService <IModelFactory>().CreateAssemblyModel(context);
model.Update(EmptyList <IUnresolvedTypeDefinition> .Instance, assembly.ProjectContent.TopLevelTypeDefinitions.ToList());
model.AssemblyName = assembly.ProjectContent.AssemblyName;
model.FullAssemblyName = assembly.ProjectContent.FullAssemblyName;
model.UpdateReferences(assembly.References);
assembly.Model = model;
}
return(assembly.Model);
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = parameter as IAssemblyModel;
if (assemblyModel == null)
{
// Node is a project?
IProject project = parameter as IProject;
if (project != null)
{
assemblyModel = project.AssemblyModel;
}
}
if (assemblyModel == null)
{
// Node is an assembly reference?
IAssemblyReferenceModel assemblyReference = parameter as IAssemblyReferenceModel;
if (assemblyReference != null)
{
// Model is an assembly reference
IAssemblyParserService assemblyParserService = SD.GetRequiredService <IAssemblyParserService>();
IEntityModelContext entityModelContext = assemblyReference.ParentAssemblyModel.Context;
CombinedAssemblySearcher searcher = new CombinedAssemblySearcher();
if ((entityModelContext != null) && (entityModelContext.Project != null))
{
searcher.AddSearcher(new ProjectAssemblyReferenceSearcher(entityModelContext.Project));
}
searcher.AddSearcher(new DefaultAssemblySearcher(assemblyReference.ParentAssemblyModel.Location));
var resolvedFile = searcher.FindAssembly(assemblyReference.AssemblyName);
if (resolvedFile != null)
{
assemblyModel = assemblyParserService.GetAssemblyModelSafe(resolvedFile);
}
else
{
// Assembly file not resolvable
SD.MessageService.ShowWarningFormatted("Could not resolve reference '{0}'.", assemblyReference.AssemblyName.ShortName);
}
}
}
if (assemblyModel != null)
{
// Try to remove AssemblyModel from list of UnpinnedAssemblies
classBrowser.UnpinnedAssemblies.Assemblies.RemoveAll(a => a.FullAssemblyName == assemblyModel.FullAssemblyName);
if (!classBrowser.MainAssemblyList.Assemblies.Contains(assemblyModel))
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
// Bring the node into view
classBrowser.GotoAssemblyModel(assemblyModel);
}
}
}
public override void Run(ResolveResult symbol)
{
var classBrowser = SD.GetService <IClassBrowser>();
var entity = GetSymbol(symbol) as IEntity;
if ((classBrowser != null) && (entity != null))
{
classBrowser.GoToEntity(entity);
}
}
static void InitializeWorkbench(Workbench workbench, IWorkbenchLayout layout)
{
SD.Services.AddService(typeof(IWorkbench), workbench);
SD.Services.AddService(typeof(IWinFormsService), new WinFormsService());
SD.Services.AddService(typeof(IWinFormsToolbarService), new WinFormsToolbarService());
SD.Services.AddService(typeof(IWinFormsMenuService), new WinFormsMenuService());
SD.Services.AddService(typeof(IProjectService), new SDProjectService());
SD.Services.AddService(typeof(IBuildService), new BuildService());
SD.Services.AddService(typeof(IParserService), new ParserService());
SD.Services.AddService(typeof(IFileService), new FileService());
SD.Services.AddService(typeof(IStatusBarService), new StatusBarService());
SD.Services.AddService(typeof(IMSBuildEngine), new MSBuildEngine());
SD.Services.AddService(typeof(IDisplayBindingService), new DisplayBindingService());
SD.Services.AddService(typeof(IBookmarkManager), new BookmarkManager());
LanguageService.ValidateLanguage();
TaskService.Initialize();
CustomToolsService.Initialize();
workbench.Initialize();
workbench.SetMemento(PropertyService.NestedProperties(workbenchMemento));
workbench.WorkbenchLayout = layout;
var applicationStateInfoService = SD.GetService <ApplicationStateInfoService>();
if (applicationStateInfoService != null)
{
applicationStateInfoService.RegisterStateGetter(activeContentState, delegate { return(SD.Workbench.ActiveContent); });
}
WorkbenchSingleton.OnWorkbenchCreated();
// initialize workbench-dependent services:
NavigationService.InitializeService();
workbench.ActiveContentChanged += delegate
{
//Debug.WriteLine("ActiveContentChanged to " + workbench.ActiveContent);
LoggingService.Debug("ActiveContentChanged to " + workbench.ActiveContent);
};
workbench.ActiveViewContentChanged += delegate
{
//Debug.WriteLine("ActiveViewContentChanged to " + workbench.ActiveViewContent);
LoggingService.Debug("ActiveViewContentChanged to " + workbench.ActiveViewContent);
};
workbench.ActiveWorkbenchWindowChanged += delegate
{
//Debug.WriteLine("ActiveWorkbenchWindowChanged to " + workbench.ActiveWorkbenchWindow);
LoggingService.Debug("ActiveWorkbenchWindowChanged to " + workbench.ActiveWorkbenchWindow);
};
}
public static void Detach(Debugger.Process process)
{
var classBrowser = SD.GetService <IClassBrowser>();
var nodes = classBrowser.AssemblyLists
.OfType <DebuggerProcessAssemblyList>()
.Where(n => n.Process == process)
.ToArray();
foreach (var node in nodes)
{
classBrowser.AssemblyLists.Remove(node);
}
}
static void InitializeWorkbench(WpfWorkbench workbench, IWorkbenchLayout layout)
{
SD.Services.AddService(typeof(IWorkbench), workbench);
UILanguageService.ValidateLanguage();
TaskService.Initialize();
Project.CustomToolsService.Initialize();
workbench.Initialize();
workbench.SetMemento(SD.PropertyService.NestedProperties(workbenchMemento));
workbench.WorkbenchLayout = layout;
// HACK: eagerly load output pad because pad services cannnot be instanciated from background threads
SD.Services.AddService(typeof(IOutputPad), CompilerMessageView.Instance);
var dlgMsgService = SD.MessageService as IDialogMessageService;
if (dlgMsgService != null)
{
dlgMsgService.DialogSynchronizeInvoke = SD.MainThread.SynchronizingObject;
dlgMsgService.DialogOwner = workbench.MainWin32Window;
}
var applicationStateInfoService = SD.GetService <ApplicationStateInfoService>();
if (applicationStateInfoService != null)
{
applicationStateInfoService.RegisterStateGetter(activeContentState, delegate {
return(SD.Workbench.ActiveContent);
});
}
WorkbenchSingleton.OnWorkbenchCreated();
// initialize workbench-dependent services:
NavigationService.InitializeService();
workbench.ActiveContentChanged += delegate {
Debug.WriteLine("ActiveContentChanged to " + workbench.ActiveContent);
LoggingService.Debug("ActiveContentChanged to " + workbench.ActiveContent);
};
workbench.ActiveViewContentChanged += delegate {
Debug.WriteLine("ActiveViewContentChanged to " + workbench.ActiveViewContent);
LoggingService.Debug("ActiveViewContentChanged to " + workbench.ActiveViewContent);
};
workbench.ActiveWorkbenchWindowChanged += delegate {
Debug.WriteLine("ActiveWorkbenchWindowChanged to " + workbench.ActiveWorkbenchWindow);
LoggingService.Debug("ActiveWorkbenchWindowChanged to " + workbench.ActiveWorkbenchWindow);
};
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = (IAssemblyModel)parameter;
// Create a new copy of this assembly model
IAssemblyModel newAssemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(assemblyModel.Context.Location), true);
if (newAssemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(newAssemblyModel);
}
}
}
ITypeDefinitionModel GetTypeDefinitionModel(ITypeDefinition mainTypeDefinition, ITypeDefinition derivedTypeDefinition)
{
ITypeDefinitionModel resolveTypeDefModel = null;
var assemblyFileName = mainTypeDefinition.ParentAssembly.GetRuntimeAssemblyLocation();
IAssemblyModel assemblyModel = null;
try {
// Try to get AssemblyModel from project list
IProjectService projectService = SD.GetRequiredService <IProjectService>();
if (projectService.CurrentSolution != null)
{
var projectOfAssembly = projectService.CurrentSolution.Projects.FirstOrDefault(p => p.AssemblyModel.Location == assemblyFileName);
if (projectOfAssembly != null)
{
// We automatically have an AssemblyModel from project
assemblyModel = projectOfAssembly.AssemblyModel;
}
}
if (assemblyModel == null)
{
// Nothing in projects, load from assembly file
var assemblyParserService = SD.GetService <IAssemblyParserService>();
if (assemblyParserService != null)
{
if (assemblyFileName != null)
{
assemblyModel = assemblyParserService.GetAssemblyModel(assemblyFileName);
}
}
}
if (assemblyModel != null)
{
// Look in found AssemblyModel
resolveTypeDefModel = assemblyModel.TopLevelTypeDefinitions[derivedTypeDefinition.FullTypeName];
if (resolveTypeDefModel != null)
{
return(resolveTypeDefModel);
}
}
} catch (Exception) {
// TODO Can't load the type, what to do?
}
return(resolveTypeDefModel);
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
IAssemblyModel assemblyModel = (IAssemblyModel)parameter;
if (assemblyModel.IsUnpinned())
{
classBrowser.UnpinnedAssemblies.Assemblies.Remove(assemblyModel);
}
else
{
classBrowser.MainAssemblyList.Assemblies.Remove(assemblyModel);
}
}
}
/// <summary>
/// Checks if an assembly model is added to the unpinned (temporary) list of ClassBrowser service.
/// </summary>
/// <param name="model">Assembly model to check.</param>
/// <returns>True if in unpinned list, false otherwise.</returns>
public static bool IsUnpinned(this IAssemblyModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
var classBrowser = SD.GetService <IClassBrowser>();
if (classBrowser != null)
{
// Look in unpinned list
return(classBrowser.UnpinnedAssemblies.Assemblies.Any(m => m.Location == model.Location));
}
return(false);
}
public SDProjectService()
{
allSolutions = new NullSafeSimpleModelCollection <ISolution>();
allProjects = allSolutions.SelectMany(s => s.Projects);
projectBindings = SD.AddInTree.BuildItems <ProjectBindingDescriptor>("/SharpDevelop/Workbench/ProjectBindings", null);
targetFrameworks = SD.AddInTree.BuildItems <TargetFramework>("/SharpDevelop/TargetFrameworks", null);
SD.GetFutureService <IWorkbench>().ContinueWith(t => t.Result.ActiveViewContentChanged += ActiveViewContentChanged).FireAndForget();
var applicationStateInfoService = SD.GetService <ApplicationStateInfoService>();
if (applicationStateInfoService != null)
{
applicationStateInfoService.RegisterStateGetter("ProjectService.CurrentSolution", delegate { return(CurrentSolution); });
applicationStateInfoService.RegisterStateGetter("ProjectService.CurrentProject", delegate { return(CurrentProject); });
}
SD.Services.AddService(typeof(IProjectServiceRaiseEvents), this);
}
public void Initialize()
{
if (initialized)
{
return;
}
initialized = true;
projectOptions = new Dictionary <string, AlFormattingPolicy>();
// Handlers for solution loading/unloading
var projectService = SD.GetService <IProjectService>();
if (projectService != null)
{
SD.ProjectService.SolutionOpened += SolutionOpened;
SD.ProjectService.SolutionClosed += SolutionClosed;
}
}
public ICompilation CreateCompilationForSingleFile(FileName fileName, IUnresolvedFile unresolvedFile)
{
DecompiledTypeReference reference = DecompiledTypeReference.FromFileName(fileName);
if (reference != null)
{
var model = SD.GetService <IClassBrowser>().FindAssemblyModel(reference.AssemblyFile);
if (model == null)
{
model = SD.AssemblyParserService.GetAssemblyModelSafe(reference.AssemblyFile, true);
}
if (model != null)
{
return(model.Context.GetCompilation());
}
}
return(new CSharpProjectContent()
.AddOrUpdateFiles(unresolvedFile)
.CreateCompilation());
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
var modelFactory = SD.GetService <IModelFactory>();
if ((classBrowser != null) && (modelFactory != null))
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Assembly files (*.exe, *.dll)|*.exe;*.dll";
openFileDialog.CheckFileExists = true;
openFileDialog.CheckPathExists = true;
if (openFileDialog.ShowDialog() ?? false)
{
IAssemblyModel assemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(openFileDialog.FileName), true);
if (assemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
}
}
}
public override void Execute(object parameter)
{
var classBrowser = SD.GetService <IClassBrowser>();
var modelFactory = SD.GetService <IModelFactory>();
if ((classBrowser != null) && (modelFactory != null))
{
OpenFromGacDialog gacDialog = new OpenFromGacDialog();
if (gacDialog.ShowDialog() ?? false)
{
foreach (string assemblyFile in gacDialog.SelectedFileNames)
{
IAssemblyModel assemblyModel = SD.AssemblyParserService.GetAssemblyModelSafe(new ICSharpCode.Core.FileName(assemblyFile), true);
if (assemblyModel != null)
{
classBrowser.MainAssemblyList.Assemblies.Add(assemblyModel);
}
}
}
}
}
public bool GoToEntity(IEntity entity)
{
// Try to find assembly in workspace
var entityAssembly = entity.ParentAssembly;
if (entityAssembly != null)
{
ITypeDefinition entityType = null;
if (entity is ITypeDefinition)
{
entityType = (ITypeDefinition)entity;
}
else
{
entityType = entity.DeclaringTypeDefinition;
}
SharpTreeNodeCollection namespaceChildren = null;
var root = this.Root as WorkspaceTreeNode;
// Try to find assembly of passed entity among open projects in solution
var solutionTreeNode = this.Root.Children.OfType <SolutionTreeNode>().FirstOrDefault();
if (solutionTreeNode != null)
{
// Ensure that we have children
solutionTreeNode.EnsureLazyChildren();
var projectTreeNode = solutionTreeNode.Children.FirstOrDefault(
node => {
if (node is ProjectTreeNode)
{
var treeNode = (ProjectTreeNode)node;
if (node.Model is IProject)
{
var projectModel = (IProject)node.Model;
return(projectModel.AssemblyModel.FullAssemblyName == entityAssembly.FullAssemblyName);
}
}
return(false);
});
if (projectTreeNode != null)
{
projectTreeNode.EnsureLazyChildren();
namespaceChildren = projectTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Try to find assembly of passed entity among additional assemblies
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Add assembly to workspace (unpinned), if not available in ClassBrowser
IAssemblyParserService assemblyParser = SD.GetService <IAssemblyParserService>();
IClassBrowser classBrowser = SD.GetService <IClassBrowser>();
if (assemblyParser != null && classBrowser != null)
{
IAssemblyModel unpinnedAssemblyModel = assemblyParser.GetAssemblyModel(new FileName(entityAssembly.UnresolvedAssembly.Location));
if (unpinnedAssemblyModel != null)
{
classBrowser.UnpinnedAssemblies.Assemblies.Add(unpinnedAssemblyModel);
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
}
}
if (namespaceChildren != null)
{
var nsTreeNode = namespaceChildren.FirstOrDefault(
node =>
(node is NamespaceTreeNode) &&
(((NamespaceTreeNode)node).Model is INamespaceModel) &&
(((INamespaceModel)((NamespaceTreeNode)node).Model).FullName == entityType.Namespace)
) as ModelCollectionTreeNode;
if (nsTreeNode != null)
{
// Ensure that we have children
nsTreeNode.EnsureLazyChildren();
SharpTreeNode entityTypeNode = null;
// Search in namespace node recursively
var foundEntityNode = nsTreeNode.FindChildNodeRecursively(
node => {
var treeNode = node as SharpTreeNode;
if (treeNode != null)
{
var treeNodeTypeModel = treeNode.Model as ITypeDefinitionModel;
if (treeNodeTypeModel != null)
{
var modelFullTypeName = treeNodeTypeModel.FullTypeName;
if (modelFullTypeName == entityType.FullTypeName)
{
// This is the TypeDefinitionModel of searched entity (the type itself or its member)
entityTypeNode = treeNode;
if (entity is ITypeDefinition)
{
// We are looking for the type itself
return(true);
}
}
}
if ((entity is IMember) && (treeNode.Model is IMemberModel))
{
// Compare parent types and member names
IMemberModel memberModel = (IMemberModel)treeNode.Model;
IMember member = (IMember)entity;
bool isSymbolOfTypeAndName =
(member.DeclaringType.FullName == memberModel.UnresolvedMember.DeclaringTypeDefinition.FullName) &&
(member.Name == memberModel.Name) &&
(member.SymbolKind == memberModel.SymbolKind);
if (isSymbolOfTypeAndName)
{
var parametrizedEntityMember = member as IParameterizedMember;
var parametrizedTreeNodeMember = memberModel.UnresolvedMember as IUnresolvedParameterizedMember;
if ((parametrizedEntityMember != null) && (parametrizedTreeNodeMember != null))
{
// For methods and constructors additionally check the parameters and their types to handle overloading properly
int treeNodeParamsCount = parametrizedTreeNodeMember.Parameters != null ? parametrizedTreeNodeMember.Parameters.Count : 0;
int entityParamsCount = parametrizedEntityMember.Parameters != null ? parametrizedEntityMember.Parameters.Count : 0;
if (treeNodeParamsCount == entityParamsCount)
{
for (int i = 0; i < entityParamsCount; i++)
{
// Compare full type names or at least only type names without namespace
// This is not precise, but sufficient in most cases.
var entityParamType = parametrizedEntityMember.Parameters[i].Type;
var treeNodeParamType = parametrizedTreeNodeMember.Parameters[i].Type.Resolve(
new SimpleTypeResolveContext(entityAssembly));
if ((entityParamType.FullName != treeNodeParamType.FullName) &&
(entityParamType.Name != treeNodeParamType.Name))
{
return(false);
}
}
// All parameters were equal
return(true);
}
}
else
{
return(true);
}
}
}
}
return(false);
});
// Special handling for default constructors: If not found, jump to type declaration instead
if ((foundEntityNode == null) && (entity.SymbolKind == SymbolKind.Constructor))
{
foundEntityNode = entityTypeNode;
}
if (foundEntityNode != null)
{
this.FocusNode(foundEntityNode);
this.SelectedItem = foundEntityNode;
return(true);
}
}
}
}
return(false);
}
public static void Attach(Debugger.Process process)
{
var classBrowser = SD.GetService <IClassBrowser>();
classBrowser.AssemblyLists.Add(new DebuggerProcessAssemblyList(process));
}
