C# IUnresolvedTypeDefinition类代码示例

 public ICompletionData CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt,
                                                          string parameterDefinition,
                                                          IUnresolvedMember currentMember,
                                                          IUnresolvedTypeDefinition currentType)
 {
     return new CompletionData(varName);
 }

		public void AddType (IUnresolvedTypeDefinition type, string shortType)
		{
			if (type == null || string.IsNullOrEmpty (shortType) || usedTypes.Contains (shortType))
				return;
			usedTypes.Add (shortType);
			result.Add (Factory.CreateTypeCompletionData (type, shortType));
		}

		public SuggestedHandlerCompletionData (Project project, CodeMemberMethod methodInfo, IType codeBehindClass, IUnresolvedTypeDefinition codeBehindClassPart)
		{
			this.project = project;
			this.methodInfo = methodInfo;
			this.codeBehindClass = codeBehindClass;
			this.codeBehindClassPart = codeBehindClassPart;
		}

		public DefaultUnresolvedField(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.SymbolKind = SymbolKind.Field;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.UnresolvedFile = declaringType.UnresolvedFile;
		}

		public DefaultUnresolvedTypeDefinition(IUnresolvedTypeDefinition declaringTypeDefinition, string name)
		{
			this.SymbolKind = SymbolKind.TypeDefinition;
			this.DeclaringTypeDefinition = declaringTypeDefinition;
			this.namespaceName = declaringTypeDefinition.Namespace;
			this.Name = name;
			this.UnresolvedFile = declaringTypeDefinition.UnresolvedFile;
		}

		public DefaultUnresolvedEvent(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.EntityType = EntityType.Event;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.ParsedFile = declaringType.ParsedFile;
		}

		public DefaultUnresolvedTypeDefinition(IUnresolvedTypeDefinition declaringTypeDefinition, string name)
		{
			this.EntityType = EntityType.TypeDefinition;
			this.DeclaringTypeDefinition = declaringTypeDefinition;
			this.namespaceName = declaringTypeDefinition.Namespace;
			this.Name = name;
			this.ParsedFile = declaringTypeDefinition.ParsedFile;
		}

		public DefaultUnresolvedMethod(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.EntityType = EntityType.Method;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.UnresolvedFile = declaringType.UnresolvedFile;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="VB6UnresolvedMethod"/> class.
 /// </summary>
 /// <param name="method">The instance of <see cref="IVbMethod"/> that is the source of this entity.</param>
 /// <param name="file">The file that is the source of this entity.</param>
 /// <param name="typeReference">The <see cref="IUnresolvedTypeReference"/> that this member is a child of. May be null.</param>
 /// <param name="typeDefinition">The <see cref="IUnresolvedTypeDefinition"/> that this entity is a child of. May be null.</param>
 internal VB6UnresolvedMethod(IVbMethod method, IUnresolvedFile file, ITypeReference typeReference, IUnresolvedTypeDefinition typeDefinition)
     : base(method, file, typeReference, typeDefinition)
 {
     if (method == null)
     {
         throw new ArgumentNullException("method");
     }
 }

 public NewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember member)
 {
     DeclarationBeginningIndex = declarationBegin;
     Type = type;
     Member = member;
     // check this:
     DeclarationCategory = type.SymbolKind.ResolveDeclarationCategoryFromSymbolKind();
     SetDefaultText(member.Name);
 }

		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = StringParser.Parse("${res:CSharpBinding.Refactoring.EventCreation.EventHandlerText}", new[] { new StringTagPair("HandlerName", handlerName) });
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}

		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = "<Create " + handlerName + ">";
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="VB6UnresolvedEntityBase"/> class.
        /// </summary>
        /// <param name="file">The file that is the source of this entity.</param>
        /// <param name="typeDefinition">The <see cref="IUnresolvedTypeDefinition"/> that this entity is a child of. May be null.</param>
        protected VB6UnresolvedEntityBase(IUnresolvedFile file, IUnresolvedTypeDefinition typeDefinition)
            : this()
        {
            this.UnresolvedFile = file;

            VB6UnresolvedFile vb6File = (VB6UnresolvedFile)file;
            this.VbpProject = vb6File.Project;

            this.DeclaringTypeDefinition = typeDefinition;
        }

            public EventCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
            {
                SetDefaultText(varName);
                DeclarationCategory = DeclarationCategory.Event;
                // what should we do with parameterDefinition???
                DelegateType = delegateType;
                CurrentMember = currentMember;
                CurrentType = currentType;

                //Description = currentMember
            }

 ContextActionViewModel MakeViewModel(IUnresolvedTypeDefinition entity)
 {
     var ambience = AmbienceService.GetCurrentAmbience();
     ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
     return new ContextActionViewModel {
         Action = new GoToDomRegionAction(entity.Region),
         Image = IconService.GetImageSource(IconService.GetImageForFile(entity.Region.FileName)),
         Comment = string.Format("(in {0})", Path.GetDirectoryName(entity.Region.FileName)),
         ChildActions = null
     };
 }