How to call a method from a different class - c#

At the moment I have created a new method in a new class, and I am trying to call this method from my main class:
Program.cs:
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
testing();
Console.ReadLine();
}
}
}
and the method is in "Class1.cs":
namespace ConsoleApplication2
{
class Class1
{
public static void testing()
{
System.Console.WriteLine("It works!");
}
}
}


You need to specify the name of the class that the method is on. So:
Class1.testing();
Sometimes you might of course need to also worry about the namespace that Class1 is in. In this case both Class1 and Main are in the same namespace. If they hadn't been though then you'd have had to call it like:
ConsoleApplication2.DifferentNamespace.Class1.testing();
or with a using declaration at the top of program.cs:
using ConsoleApplication2.DifferentNamespace


You have made testing a static method, so you can call the method in this fashion
static void Main(string[] args)
{
Class1.testing();
Console.ReadLine();
}
Is this what you want ?


You are missing the class declaration in order to use the static method:
Class1.testing();


Class 1 has to be a public class and then you can call Class1.testing()

Related

How to define a method following top-level statements

I recently updated Visual Studio and found out about this new feature (to me it is new) of top-level statements.
As I understand it, the compiler completes the definitions for the Program class and Main method, without you having to explicitly type it up.
This is useful, but I'm having trouble when defining a new method. I would like a method in the Program class. And call this with a top-level statement. Here is some example code:
Console.WriteLine("toplevel");
ThisShouldBeAMethodOfProgramClass();
public static void ThisShouldBeAMethodOfProgramClass()
{
Console.WriteLine("Static in Program class");
}
This is giving me build errors, because the public static modifiers are not valid. I think it interprets this as a local function in Main. I can remove the modifiers, but this is just example code, my real code has more methods and classes.
How can I do this? Should I not use top-level for this?
I would like this to effectively be the same as:
class Program
{
public static void Main(string[] args)
{
Console.WriteLine("toplevel");
ThisShouldBeAMethodOfProgramClass();
}
public static void ThisShouldBeAMethodOfProgramClass()
{
Console.WriteLine("Static in Program class");
}
}

You can keep using top-level statements and append additional members with a partial Program class.
using System;
Console.WriteLine("toplevel");
ThisShouldBeAMethodOfProgramClass();
public static partial class Program
{
public static void ThisShouldBeAMethodOfProgramClass()
{
Console.WriteLine("Static in Program class");
}
}

Or just remove the access modifier: method without access modifier
using System;
Console.WriteLine("toplevel");
ThisShouldBeAMethodOfProgramClass();
static void ThisShouldBeAMethodOfProgramClass()
{
Console.WriteLine("Static in Program class");
}

Why doesn't "using static" work for System.Reactive.Linq.Observable in C# [duplicate]

Background:
I had a static class, but the static methods weren't extension methods. I decided to refactor the methods into extension methods and didn't expect any code to break since extension methods can be called like static methods. However, code did break when static import was used for the static class holding the extension methods.
Example:
I have a static class with an extension method and a static method:
namespace UsingStaticExtensionTest.Extensions
{
static class ExtensionClass
{
internal static void Test1(this Program pg)
{
System.Console.WriteLine("OK");
}
internal static void Test2(Program pg)
{
System.Console.WriteLine("OK");
}
}
}
When I use the following using directive, everything in the test program works fine:
using UsingStaticExtensionTest.Extensions;
namespace UsingStaticExtensionTest
{
class Program
{
static void Main(string[] args)
{
var p = new Program();
ExtensionClass.Test1(p); // OK
p.Test1(); // OK
ExtensionClass.Test2(p); // OK
}
}
}
But when I use the static import using directive to identify just the class with the extension method, I can't call the extension method as a static method:
using static UsingStaticExtensionTest.Extensions.ExtensionClass;
class Program
{
static void Main(string[] args)
{
var p = new Program();
//Test1(p); // Error: The name Test1 does not exist in the current context
p.Test1(); // OK
Test2(p); // OK **I can still call the static method**
}
}
}
Question:
Why can't I call an extension method as a static method when using a static import?

Because of language design:
Using static makes extension methods declared in the specified type
available for extension method lookup. However, the names of the
extension methods are not imported into scope for unqualified
reference in code.
using Directive

Why can't I call an extension method as a static method when using static import?

Background:
I had a static class, but the static methods weren't extension methods. I decided to refactor the methods into extension methods and didn't expect any code to break since extension methods can be called like static methods. However, code did break when static import was used for the static class holding the extension methods.
Example:
I have a static class with an extension method and a static method:
namespace UsingStaticExtensionTest.Extensions
{
static class ExtensionClass
{
internal static void Test1(this Program pg)
{
System.Console.WriteLine("OK");
}
internal static void Test2(Program pg)
{
System.Console.WriteLine("OK");
}
}
}
When I use the following using directive, everything in the test program works fine:
using UsingStaticExtensionTest.Extensions;
namespace UsingStaticExtensionTest
{
class Program
{
static void Main(string[] args)
{
var p = new Program();
ExtensionClass.Test1(p); // OK
p.Test1(); // OK
ExtensionClass.Test2(p); // OK
}
}
}
But when I use the static import using directive to identify just the class with the extension method, I can't call the extension method as a static method:
using static UsingStaticExtensionTest.Extensions.ExtensionClass;
class Program
{
static void Main(string[] args)
{
var p = new Program();
//Test1(p); // Error: The name Test1 does not exist in the current context
p.Test1(); // OK
Test2(p); // OK **I can still call the static method**
}
}
}
Question:
Why can't I call an extension method as a static method when using a static import?

Because of language design:
Using static makes extension methods declared in the specified type
available for extension method lookup. However, the names of the
extension methods are not imported into scope for unqualified
reference in code.
using Directive

Define C# class outside of any namespace

Is it possible to define a class (not interface) outside of any namespace?

Ran a test and yes you can. Here's my code built off of a Console App:
using System;
using System.Text;
namespace With_Console_App
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("This will output something: ");
Console.ReadLine();
some.Print();
Console.ReadLine();
}
}
}
class some
{
public static void Print()
{
Console.WriteLine("something");
}
}
Yes, you can define a class outside of a namespace. Per juharr it ends up in the default global namespace.

C # beginner. Compiler errors

I am new to C# and visual studio 2005
I created a new Console Application project in VS2005 and added a Class1.cs file to the existing Program.cs file that was created by default.
The Class1.cs file has the following simple code:
public class Class1
{
public Class1()
{
}
~Class1()
{
}
public void PrintMessage()
{
Console.WriteLine("\nHello\n");
Console.Read();
}
}
And program.cs file has the following:
class Program
{
static void Main(string[] args)
{
PrintMessage();
}
}
When I try to compile I get the following error:
The name 'PrintMessage' does not exist in the current context.
Any help?
Thanks, Viren

Try:
Class1 myClass = new Class1();
myClass.PrintMessage();
Or, what might be better since this seems like a utility function. Change your method definition to:
public static void PrintMessage()
So you can call it directly.
Class1.PrintMessage();

The name 'PrintMessage' does not exist in the current context.
It exists in another context - that of class Class1. Since it is a public function of that (public) class, you can use it, by creating an instance of Class1 (the PrintMessage function is not static, so you need an instance of Class1 to call it) and then invoking the PrintMessage function on it.
class Program
{
static void Main(string[] args)
{
Class1 someClass1Object = new Class1();
someClass1Object.PrintMessage();
}
}

PrintMessage is not a method of the class "Program", it's a method of Class1. Try
Class1 c = new Class1();
c.PrintMessage();
You probably also want to go through a tutorial or two :)

class Program
{
static void Main(string[] args)
{
new Class1().PrintMessage();
}
}
or make PrintMessage() to be static so you can use it next way:
public class Class1
{
public static void PrintMessage()
{
// ..
}
}
class Program
{
static void Main(string[] args)
{
Class1.PrintMessage();
}
}

You need a reference to the class where the method is. You must do that with:
Class1.PrintMessages();
Since Class1 is not static, you also need an instance of that class. You could do that with:
Class1 c = new Class1();
Finally, you have to call the method prefixed with the instance variable. Your code will look something like this:
Class1 c = new Class1();
c.PrintMessages();
If you want, you can shorten this code with the sentence
new Class1().PrintMessages();
that do the same as before.

Calling PrintMessage() inside of your Main function (which is a function on the Program class) means that the compiler is going to look for a function called PrintMessage() somewhere in the program class.
What you have is called an instance function on the Class1 class. In order to call this type of function, you need an instance of Class1 in your function. Something like this:
static void Main(string[] args)
{
Class1 myClass = new Class1();
myClass.PrintMessage();
}

Making the method static is probably what you want, rather than the other suggestions here:
public static void PrintMessage()
{
Console.WriteLine("\nHello\n");
Console.Read();
}
static tells the compiler that this method doesn't depend on an instance of a class. If that doesn't mean anything to you, read up on the topic of classes in your favourite C# book.

You need a reference to the Class1 class in order to call a method of the class. Try:
Class1 myClass = new Class1();
myClass.PrintMessage();

Your PrintMessage() method is a method of the Class1 class. You have to reference that class to get to the method.
class Program
{
static void Main(string[] args)
{
Class1 c = new Class1(); //Create an instance of your class
c.PrintMessage(); //Call the PrintMessage method of class Class1
}
}
Note: You may want to rename Class1 to something more descriptive.

Print message is not a part of Main:
u have to tell it where it is:
Class1 messageClass = new Class1();
messageClass.PrintMessage();

you need to reference the class that print message . . . AKA: Class1.PrintMessage()

Categories