Example #1
0
		public static ClassDeclarationSyntax WithViewsClass(this ClassDeclarationSyntax node, IEnumerable<View> viewFiles)
		{
			// create subclass called ViewsClass
			// create ViewNames get property returning static instance of _ViewNamesClass subclass
			//	create subclass in ViewsClass called _ViewNamesClass 
			//		create string field per view
			const string viewNamesClass = "_ViewNamesClass";
			var viewClassNode =
				CreateClass("ViewsClass", null, SyntaxKind.PublicKeyword)
					.WithAttributes(CreateGeneratedCodeAttribute(), CreateDebugNonUserCodeAttribute())
					.WithField("s_ViewNames", viewNamesClass, SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword);

			var viewNamesClassNode = CreateClass(viewNamesClass, null, SyntaxKind.PublicKeyword);
			var controllerViews =
				viewFiles.Where(x => x.ControllerName.Equals(node.Identifier.ToString(), StringComparison.CurrentCultureIgnoreCase))
					.ToImmutableArray();
			var viewNameFields =
				controllerViews.Select(
					x => CreateStringFieldDeclaration(x.ViewName, x.ViewName, SyntaxKind.PublicKeyword, SyntaxKind.ReadOnlyKeyword))
					.Cast<MemberDeclarationSyntax>()
					.ToArray();
			viewNamesClassNode = viewNamesClassNode.AddMembers(viewNameFields);

			viewClassNode = viewClassNode.AddMembers(viewNamesClassNode);
			var viewFields =
				controllerViews.Select(
					x => CreateStringFieldDeclaration(x.ViewName, "~/" + x.RelativePath, SyntaxKind.PublicKeyword))
					.Cast<MemberDeclarationSyntax>()
					.ToArray();
			viewClassNode = viewClassNode.AddMembers(viewFields);

			return node.AddMembers(viewClassNode);
		}
 public static NamespaceDeclarationSyntax AddStructs(this NamespaceDeclarationSyntax @this,
     params StructDeclarationSyntax[] @structsSyntax)
 {
     return @this.AddMembers(@structsSyntax);
 }
 public static NamespaceDeclarationSyntax AddNamespaces(this NamespaceDeclarationSyntax @this,
     params NamespaceDeclarationSyntax[] @namespaceSyntax)
 {
     return @this.AddMembers(@namespaceSyntax);
 }
 public static NamespaceDeclarationSyntax AddInterfaces(this NamespaceDeclarationSyntax @this,
     params InterfaceDeclarationSyntax[] @interfacesSyntax)
 {
     return @this.AddMembers(@interfacesSyntax);
 }
 public static NamespaceDeclarationSyntax AddEnums(this NamespaceDeclarationSyntax @this,
     params EnumDeclarationSyntax[] @enumsSyntax)
 {
     return @this.AddMembers(@enumsSyntax);
 }
 public static NamespaceDeclarationSyntax AddDelegates(this NamespaceDeclarationSyntax @this,
     params DelegateDeclarationSyntax[] @delegatesSyntax)
 {
     return @this.AddMembers(@delegatesSyntax);
 }
 public static NamespaceDeclarationSyntax AddClasses(this NamespaceDeclarationSyntax @this,
     params ClassDeclarationSyntax[] @classesSyntax)
 {
     return @this.AddMembers(@classesSyntax);
 }
Example #8
0
        private static TypeDeclarationSyntax WithPropertyChangedEvent(this TypeDeclarationSyntax node, TypeDeclarationSyntax original, SemanticModel semanticModel, Workspace workspace)
        {
            var classSymbol = semanticModel.GetDeclaredSymbol(original);
            var interfaceSymbol = semanticModel.Compilation.GetTypeByMetadataName(InterfaceName);
            var propertyChangedEventSymbol = (IEventSymbol)interfaceSymbol.GetMembers("PropertyChanged").Single();
            var propertyChangedEvent = classSymbol.FindImplementationForInterfaceMember(propertyChangedEventSymbol);

            // Does this class contain an implementation for the PropertyChanged event? If not, add it.
            if (propertyChangedEvent == null)
            {
                var propertyChangedEventDecl = GeneratePropertyChangedEvent();
                node = node.AddMembers(propertyChangedEventDecl);
            }

            return node;
        }
 public static EnumDeclarationSyntax AddConstants(this EnumDeclarationSyntax @this,
     params EnumMemberDeclarationSyntax[] @enumMemberSyntax)
 {
     return @this.AddMembers(@enumMemberSyntax);
 }
 /// <summary>
 /// Returns the given class with a private parameterless constructor added.
 /// </summary>
 public static ClassDeclarationSyntax AddPrivateConstructor(this ClassDeclarationSyntax classDeclaration)
 {
     return classDeclaration.AddMembers(
         SyntaxEx.ConstructorDeclaration(
             new[] { SyntaxKind.PrivateKeyword }, classDeclaration.Identifier.ValueText));
 }
Example #11
0
		public static ClassDeclarationSyntax WithStaticFieldsForFiles(this ClassDeclarationSyntax node, IEnumerable<StaticFile> staticFiles)
		{
			var staticNodes =
				staticFiles.Select(
					x => CreateStringFieldDeclaration(x.FileName, x.RelativePath.ToString(), SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
					.Cast<MemberDeclarationSyntax>()
					.ToArray();
			return node.AddMembers(staticNodes);
		}
Example #12
0
		public static ClassDeclarationSyntax WithControllerFields(
			this ClassDeclarationSyntax node,
			IEnumerable<ClassDeclarationSyntax> controllers)
		{
			// TODO field name should be overriddable via config, stripping off 'controller' by default
			// TODO add extension method to customise field initializer as this needs to be the one returned from GetR4MVCControllerClassName
			return node.AddMembers(
				controllers.Select(
					x => CreateFieldWithDefaultInitializer(
						x.Identifier.ToString().Replace("Controller", string.Empty),
						x.ToQualifiedName(),
						SyntaxKind.PublicKeyword,
						SyntaxKind.StaticKeyword)).Cast<MemberDeclarationSyntax>().ToArray());

		}
Example #13
0
		public static NamespaceDeclarationSyntax WithDummyClass(this NamespaceDeclarationSyntax node)
		{
			const string dummyClassName = "Dummy";
			var dummyClass =
				CreateClass(dummyClassName)
					.WithModifiers(SyntaxKind.PublicKeyword)
					.WithAttributes(CreateGeneratedCodeAttribute(), CreateDebugNonUserCodeAttribute())
					.WithDefaultConstructor(false, SyntaxKind.PrivateKeyword)
					.WithField("Instance", dummyClassName, SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword);

			return node.AddMembers(dummyClass);
		}
 public static Task<System.Boolean> AddMembersAsync(this Organization target,List<ReactiveRTM.SDOPackage.SDO> sdoList)
 {
     return Task.Factory.StartNew(()=>{
         var ret = target.AddMembers(sdoList);
         return ret;
     });
 }