We Keep Coding

Expected class, delegate, enum, interface, or struct (CS1518)

simple code here and the answers I find don't seem to work.
I'm using
SharpDevelop Version : 3.2.1.6466
.NET Version : 2.0.50727.5485
The problem is the error code
Expected class, delegate, enum, interface, or struct (CS1518).
Any ideas?
Program.cs codes:
using System;
using System.Threading;
namespace Threshold
{
public class Class1
{
public Class1()
{
Heritage YOLO = new Heritage();
YOLO.Fractal();
}
}
static void Main()
{
//do nothing
}
}
The cs file it calls is:
using System;
using System.Threading;
namespace Threshold
{
public class Heritage
{
int Fractal()
{
//Do stuff.
}
}
internal partial class DefineConstants
{
public const string DRIVERPATH = "d:\\tc\\bgi";
}
}
Please help with a fix.
Thanks.

Your main method is outside the class. Put it inside.

Can I use C# OrderBy of linq in CodeHunt

Problem Description
using System;
using System.Linq;
public static class Program {
public static int[] Puzzle(int[] a) {
return a.OrderBy(s => s).ToArray();
}
}
My code and wrong information
Bad Dependency
[System.Core]System.Linq.IOrderedEnumerable`1
Why I am wrong？Whether or not the platform can support OrderBy？Do I need a custom sort function？The code can run successful in VS2015, I have tried.
www.codehunt.com

Try follow.
using System;
using System.Linq;
public static class Program {
public static int[] Puzzle(int[] a)
{
return Array.Sort(a);
}
}

AST walker doesn't seem to work fine

I am using Roslyn and I have created an AST walker in order to detect when certain nodes are traversed.
The source I am trying to parse is the following:
var source = string.Format(#"
using System;
using System.Collections;
using System.Linq;
using System.Text;
namespace HelloWorld
{{
class {0} : {1}
{{
static void Main(string[] args)
{{
Console.WriteLine(""Hello, World!"");
}}
}}
}}", "MyClass", "MyBaseClass");
And this is the walker:
namespace MyStuff
{
using System;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
public class MyWalker : CSharpSyntaxWalker
{
public MyWalker(SyntaxNode node) :
base(SyntaxWalkerDepth.StructuredTrivia)
{
this.Root = node;
}
public SyntaxNode Root { get; private set; }
public void Start()
{
this.Visit(this.Root);
}
sealed public override void VisitAccessorDeclaration(AccessorDeclarationSyntax node)
{
this.DoSomething(node, this.type.IsInstanceOfType(node));
}
...
sealed public override void VisitYieldStatement(YieldStatementSyntax node)
{
this.DoSomething(node, this.type.IsInstanceOfType(node));
}
// BREAKPOINT IN THE BODY OF THIS FUNCTION!
private void DoSomething(SyntaxNode node)
{
...
}
}
}
I am overriding all visit methods, alphabetically from VisitAccessorDeclaration to VisitYieldStatement. I am doing this just to try stuff, not for real applications, I know it is quite nonsense.
Visiting
I run it:
SyntaxNode root = CSharpSyntaxTree.ParseText(source).GetRoot();
And then run the walker:
var astWalker = new MyWalker(this.Root);
astExecutor.Start();
// NEXT OPERATION
What happens? I seta breakpoint on function DoSomething and I expect it to be it a lot of times. Actually it does not happen. It happens only for one node: VisitCompilationUnit. After the control flow passes on on // NEXT OPERATION and that's it.
What am I missing? Thanks

In your overrides, you need to call the base version of the method you are overriding. We allow you to stop the walk. By not calling base so that if you are trying to visit only specific nodes, you can control it.

Namespace issue with period

I have a class:
namespace FooIOS
{
public class Foo
{
public static void doThis() {...}
}
}
And this works:
using FooIOS;
namespace Sample.iOS
{
public void method () {
Foo.doThis();
}
}
However, this does not work the same way when I change the namespace to insert a period:
namespace Foo.iOS
{
public class Foo
{
public static void doThis() {...}
}
}
using Foo.iOS;
namespace Sample.iOS
{
public void method () {
// Compilation error
Foo.doThis();
// Compilation error
Foo.iOS.doThis()
// This works but I can't have it that long and complicated (I'm writing an API call)
Foo.iOS.Foo.doThis();
}
}
I'm pretty inexperienced with C# and I'm wondering if there's any way to use the period in the namespace and not deal with the complicated call.

namespace Foo.iOS
{
public class Foo
{
public static void doThis() {...}
}
}
Your namespace name is Foo.iOS, class name is Foo, static method name is doThis(). The fully qualified path to access that method is NAMESPACE.CLASS.METHOD_NAME, so it becomes:
Foo.iOS.Foo.doThis();
Here is nothing wrong with C#, but with the naming you use.
From this a couple of suggestions:
try to no use . inside names of the namespace, as this introduces confusion
try to not name namespace as the class inside it, as this introduces confusion.
I'm pretty inexperienced with C# and I'm wondering if there's any way
to use the period in the namespace and not deal with the complicated
call.
Short answer is: name your namespaces, classes and member functions in a way, that it does not look complicated to you and to others.
EDIT
Consider that you can use also Namespace Alias.
For example:
using IOS = Foo.iOS;
...
IOS.Foo.doThis();
But as I said before, it's better to avoid . in namespace name at first place.

Bring the using Foo.iOS; statement inside the namespace Sample.iOS namespace block, like shown below, then you will be able to call doThis() like in your 1st attempt Foo.doThis(); that was previously giving you a compile error.
namespace Sample.iOS
{
using Foo.iOS;
public void method () {
// this works
Foo.doThis();
}
}
Related reading: Inside or Outside? by Eric Lippert on MSDN.
Fully working Code sample:
Create a new Console App in Visual Studio, and then in the Program.cs class, delete all lines, paste the following, do a compile and then run.
using System;
namespace Foo.iOS
{
public class Foo
{
public static void doThis() { Console.Write("Inside doThis");}
}
}
namespace Sample.iOS
{
using Foo.iOS;
class Program
{
static void Main(string[] args)
{
method();
Console.ReadKey();
}
public static void method ()
{
// works fine
Foo.doThis();
}
}
}

Class structure confirmation

I have this class file call SMSHelper.cs First I just wanted to know is my written structure is Correct or Wrong?(My class file name is also SMSHelper.cs & my first class also SMSHelper here you can see in the code.).
Basically I have 3 classes in same file. One class has the same name as the file name.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.Text.RegularExpressions;
namespace SMSBase.SMSFunction
{
public class SMSHelper : DotNetNuke.Entities.Modules.PortalModuleBase
{
// Some Code here
// Return Something here
}
public class Validator
{
public bool IsValidate(string Item)
{
// Some Code Here Not return anything
}
public class HuntingDate
{
//Implementation & Constructor here.. Return Something
}
}
}

There is nothing wrong in your class structure (except one missing bracket). And there is no matter your class name and file name are same. You can access and initialize your class objects like that...
SMSBase.SMSFunction.SMSHelper objSMSHelper = new SMSBase.SMSFunction.SMSHelper();
SMSBase.SMSFunction.Validator objValidator = new SMSBase.SMSFunction.Validator();
SMSBase.SMSFunction.HuntingDate objHuntingDate = new SMSBase.SMSFunction.HuntingDate();
This SMSBase.SMSFunction is your namespace... you can access classes by your namespace or include this namespace in the class header like
using SMSBase.SMSFunction

There is a problem in opening closing brackets:
namespace SMSBase.SMSFunction
{
public class SMSHelper : DotNetNuke.Entities.Modules.PortalModuleBase
{ // Some Code here // Return Something here
}
public class Validator
{
public bool IsValidate(string Item)
{ // Some Code Here Not return anything
}
}
public class HuntingDate
{ //Implementation & Constructor here.. Return Something
}
}
If that is what you are asking.

Yes as Talha ,said one bracket is missing.Try to put that.
When we want to call the class name its better to call with "namespace.ClassName" format which gives clarity to the compiler.